Add 4-bit count trailing zeros threshold circuit

10 neurons, 3 layers, 37 parameters, magnitude 30.

.gitattributes

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

README.md

@@ -0,0 +1,103 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- bit-manipulation
+---
+
+# threshold-ctz4
+
+4-bit count trailing zeros. Returns the number of consecutive zero bits starting from the LSB.
+
+## Function
+
+ctz4(x3, x2, x1, x0) -> count (0-4)
+
+- CTZ = 0 if x0 = 1 (no trailing zeros)
+- CTZ = 1 if x0 = 0, x1 = 1
+- CTZ = 2 if x0 = x1 = 0, x2 = 1
+- CTZ = 3 if x0 = x1 = x2 = 0, x3 = 1
+- CTZ = 4 if all bits are zero
+
+## Truth Table (selected rows)
+
+| Input | CTZ | Output |
+|-------|-----|--------|
+| 0001 | 0 | 000 |
+| 0010 | 1 | 001 |
+| 0100 | 2 | 010 |
+| 1000 | 3 | 011 |
+| 0000 | 4 | 100 |
+| 0110 | 1 | 001 |
+| 1100 | 2 | 010 |
+
+## Architecture
+
+```
+x3 x2 x1 x0
+    │
+    ▼
+┌─────────────────────────────────┐
+│ Layer 1: Prefix conditions      │
+│ p0 = (x0=0)                     │
+│ p01 = (x0=x1=0)                 │
+│ p012 = (x0=x1=x2=0)             │
+│ all_zero = (all=0)              │
+└─────────────────────────────────┘
+    │
+    ▼
+┌─────────────────────────────────┐
+│ Layer 2: One-hot position       │
+│ z1 = p0 AND x1                  │
+│ z2 = p01 AND x2                 │
+│ z3 = p012 AND x3                │
+└─────────────────────────────────┘
+    │
+    ▼
+┌─────────────────────────────────┐
+│ Layer 3: Binary encoding        │
+│ y2 = all_zero                   │
+│ y1 = z2 OR z3                   │
+│ y0 = z1 OR z3                   │
+└─────────────────────────────────┘
+    │
+    ▼
+  y2 y1 y0
+```
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 4 |
+| Outputs | 3 |
+| Neurons | 10 |
+| Layers | 3 |
+| Parameters | 37 |
+| Magnitude | 30 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+# ctz4(0,1,0,0) = 2 (binary 0100 has 2 trailing zeros)
+# See model.py for full implementation
+```
+
+## Applications
+
+- Finding the lowest set bit position
+- Efficient division by powers of 2
+- Bit manipulation in cryptography
+- Hardware priority encoders
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-ctz4",
+  "description": "4-bit count trailing zeros",
+  "inputs": 4,
+  "outputs": 3,
+  "neurons": 10,
+  "layers": 3,
+  "parameters": 37
+}

create_safetensors.py

@@ -0,0 +1,134 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+# CTZ4: Count Trailing Zeros (4-bit)
+# Inputs: x3, x2, x1, x0 (x0 is LSB)
+# Output: 3-bit count (0-4)
+#
+# CTZ = 0 if x0 = 1
+# CTZ = 1 if x0 = 0, x1 = 1
+# CTZ = 2 if x0 = x1 = 0, x2 = 1
+# CTZ = 3 if x0 = x1 = x2 = 0, x3 = 1
+# CTZ = 4 if all zeros
+#
+# Output encoding: y2 y1 y0
+# 0 -> 000, 1 -> 001, 2 -> 010, 3 -> 011, 4 -> 100
+
+# Layer 1: Compute prefix conditions (all lower bits are zero)
+# p0 = (x0 = 0)
+weights['p0.weight'] = torch.tensor([[0.0, 0.0, 0.0, -1.0]], dtype=torch.float32)
+weights['p0.bias'] = torch.tensor([0.0], dtype=torch.float32)
+
+# p01 = (x0 = 0 AND x1 = 0)
+weights['p01.weight'] = torch.tensor([[0.0, 0.0, -1.0, -1.0]], dtype=torch.float32)
+weights['p01.bias'] = torch.tensor([0.0], dtype=torch.float32)
+
+# p012 = (x0 = 0 AND x1 = 0 AND x2 = 0)
+weights['p012.weight'] = torch.tensor([[0.0, -1.0, -1.0, -1.0]], dtype=torch.float32)
+weights['p012.bias'] = torch.tensor([0.0], dtype=torch.float32)
+
+# all_zero = (all bits = 0)
+weights['all_zero.weight'] = torch.tensor([[-1.0, -1.0, -1.0, -1.0]], dtype=torch.float32)
+weights['all_zero.bias'] = torch.tensor([0.0], dtype=torch.float32)
+
+# Layer 2: Compute one-hot position indicators
+# z1 = p0 AND x1 (first 1 is at position 1)
+weights['z1.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['z1.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# z2 = p01 AND x2 (first 1 is at position 2)
+weights['z2.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['z2.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# z3 = p012 AND x3 (first 1 is at position 3)
+weights['z3.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['z3.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# Layer 3: Encode to binary output
+# y2 = all_zero (CTZ = 4)
+weights['y2.weight'] = torch.tensor([[1.0]], dtype=torch.float32)
+weights['y2.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# y1 = z2 OR z3 (CTZ in {2, 3})
+weights['y1.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['y1.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# y0 = z1 OR z3 (CTZ in {1, 3})
+weights['y0.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['y0.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+save_file(weights, 'model.safetensors')
+
+def ctz4(x3, x2, x1, x0):
+    inp = torch.tensor([float(x3), float(x2), float(x1), float(x0)])
+
+    # Layer 1
+    p0 = int((inp @ weights['p0.weight'].T + weights['p0.bias'] >= 0).item())
+    p01 = int((inp @ weights['p01.weight'].T + weights['p01.bias'] >= 0).item())
+    p012 = int((inp @ weights['p012.weight'].T + weights['p012.bias'] >= 0).item())
+    all_zero = int((inp @ weights['all_zero.weight'].T + weights['all_zero.bias'] >= 0).item())
+
+    # Layer 2
+    l2_z1 = torch.tensor([float(p0), float(x1)])
+    z1 = int((l2_z1 @ weights['z1.weight'].T + weights['z1.bias'] >= 0).item())
+
+    l2_z2 = torch.tensor([float(p01), float(x2)])
+    z2 = int((l2_z2 @ weights['z2.weight'].T + weights['z2.bias'] >= 0).item())
+
+    l2_z3 = torch.tensor([float(p012), float(x3)])
+    z3 = int((l2_z3 @ weights['z3.weight'].T + weights['z3.bias'] >= 0).item())
+
+    # Layer 3
+    l3_y2 = torch.tensor([float(all_zero)])
+    y2 = int((l3_y2 @ weights['y2.weight'].T + weights['y2.bias'] >= 0).item())
+
+    l3_y1 = torch.tensor([float(z2), float(z3)])
+    y1 = int((l3_y1 @ weights['y1.weight'].T + weights['y1.bias'] >= 0).item())
+
+    l3_y0 = torch.tensor([float(z1), float(z3)])
+    y0 = int((l3_y0 @ weights['y0.weight'].T + weights['y0.bias'] >= 0).item())
+
+    return y2, y1, y0
+
+def reference_ctz4(x3, x2, x1, x0):
+    if x0 == 1:
+        return 0
+    if x1 == 1:
+        return 1
+    if x2 == 1:
+        return 2
+    if x3 == 1:
+        return 3
+    return 4
+
+print("Verifying CTZ4...")
+errors = 0
+for i in range(16):
+    x3, x2, x1, x0 = (i >> 3) & 1, (i >> 2) & 1, (i >> 1) & 1, i & 1
+    y2, y1, y0 = ctz4(x3, x2, x1, x0)
+    result = y2 * 4 + y1 * 2 + y0
+    expected = reference_ctz4(x3, x2, x1, x0)
+    if result != expected:
+        errors += 1
+        print(f"ERROR: {x3}{x2}{x1}{x0} -> {result}, expected {expected}")
+
+if errors == 0:
+    print("All 16 test cases passed!")
+else:
+    print(f"FAILED: {errors} errors")
+
+print("\nTruth Table:")
+print("x3 x2 x1 x0 | CTZ | y2 y1 y0")
+print("-" * 30)
+for i in range(16):
+    x3, x2, x1, x0 = (i >> 3) & 1, (i >> 2) & 1, (i >> 1) & 1, i & 1
+    y2, y1, y0 = ctz4(x3, x2, x1, x0)
+    result = y2 * 4 + y1 * 2 + y0
+    print(f" {x3}  {x2}  {x1}  {x0}  |  {result}  |  {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,37 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def ctz4(x3, x2, x1, x0, weights):
+    """4-bit count trailing zeros: returns number of trailing 0 bits (0-4)."""
+    inp = torch.tensor([float(x3), float(x2), float(x1), float(x0)])
+
+    # Layer 1: prefix conditions
+    p0 = int((inp @ weights['p0.weight'].T + weights['p0.bias'] >= 0).item())
+    p01 = int((inp @ weights['p01.weight'].T + weights['p01.bias'] >= 0).item())
+    p012 = int((inp @ weights['p012.weight'].T + weights['p012.bias'] >= 0).item())
+    all_zero = int((inp @ weights['all_zero.weight'].T + weights['all_zero.bias'] >= 0).item())
+
+    # Layer 2: one-hot position
+    z1 = int((torch.tensor([float(p0), float(x1)]) @ weights['z1.weight'].T + weights['z1.bias'] >= 0).item())
+    z2 = int((torch.tensor([float(p01), float(x2)]) @ weights['z2.weight'].T + weights['z2.bias'] >= 0).item())
+    z3 = int((torch.tensor([float(p012), float(x3)]) @ weights['z3.weight'].T + weights['z3.bias'] >= 0).item())
+
+    # Layer 3: binary encoding
+    y2 = int((torch.tensor([float(all_zero)]) @ weights['y2.weight'].T + weights['y2.bias'] >= 0).item())
+    y1 = int((torch.tensor([float(z2), float(z3)]) @ weights['y1.weight'].T + weights['y1.bias'] >= 0).item())
+    y0 = int((torch.tensor([float(z1), float(z3)]) @ weights['y0.weight'].T + weights['y0.bias'] >= 0).item())
+
+    return y2, y1, y0
+
+if __name__ == '__main__':
+    w = load_model()
+    print('CTZ4 examples:')
+    examples = [0b0001, 0b0010, 0b0100, 0b1000, 0b0000, 0b0110, 0b1100]
+    for val in examples:
+        x3, x2, x1, x0 = (val >> 3) & 1, (val >> 2) & 1, (val >> 1) & 1, val & 1
+        y2, y1, y0 = ctz4(x3, x2, x1, x0, w)
+        count = y2 * 4 + y1 * 2 + y0
+        print(f'  {val:04b} -> {count}')

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:966c1503a6657d088a8aa946e88255100a5b55172418f1fe13e3c1c640b44a57
+size 1452