Upload folder using huggingface_hub

README.md

@@ -0,0 +1,161 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- bit-manipulation
+- ctz
+---
+
+# threshold-ctz8
+
+8-bit count trailing zeros (CTZ). Returns the number of trailing zero bits before the first set bit. Returns 8 if input is zero.
+
+## Circuit
+
+```
+ x7  x6  x5  x4  x3  x2  x1  x0
+  │   │   │   │   │   │   │   │
+  └───┴───┴───┴───┴───┴───┴───┘
+              │
+              ▼
+    ┌─────────────────────┐
+    │  Priority Detect    │    Layer 1-3
+    │  (find first 1)     │
+    └─────────────────────┘
+              │
+              ▼
+    ┌─────────────────────┐
+    │  Position Encoder   │    Layer 4-5
+    │  (binary encoding)  │
+    └─────────────────────┘
+              │
+              ▼
+        [c2, c1, c0]
+        (count 0-7)
+
+    Plus: all_zero detector for count=8
+```
+
+## Function
+
+```
+ctz8(x7, x6, x5, x4, x3, x2, x1, x0) -> (c3, c2, c1, c0)
+
+where c = 4*c3 + 2*c2 + c1 + c0 = number of trailing zeros
+```
+
+If x0 is set, count = 0. If only x7 is set, count = 7. If no bits set, count = 8.
+
+## Truth Table (selected)
+
+| Input (hex) | Binary | CTZ | c3 c2 c1 c0 |
+|-------------|--------|:---:|-------------|
+| 0x01 | 00000001 | 0 | 0 0 0 0 |
+| 0x02 | 00000010 | 1 | 0 0 0 1 |
+| 0x04 | 00000100 | 2 | 0 0 1 0 |
+| 0x08 | 00001000 | 3 | 0 0 1 1 |
+| 0x10 | 00010000 | 4 | 0 1 0 0 |
+| 0x20 | 00100000 | 5 | 0 1 0 1 |
+| 0x40 | 01000000 | 6 | 0 1 1 0 |
+| 0x80 | 10000000 | 7 | 0 1 1 1 |
+| 0x00 | 00000000 | 8 | 1 0 0 0 |
+| 0x06 | 00000110 | 1 | 0 0 0 1 |
+| 0xF0 | 11110000 | 4 | 0 1 0 0 |
+
+## Mechanism
+
+**Step 1: Find first set bit from LSB**
+
+Detect positions where a bit is set and all lower bits are zero:
+
+| Signal | Condition | Meaning |
+|--------|-----------|---------|
+| p0 | x0 | First 1 at position 0 |
+| p1 | x1 AND NOT x0 | First 1 at position 1 |
+| p2 | x2 AND NOT x1 AND NOT x0 | First 1 at position 2 |
+| ... | ... | ... |
+| p7 | x7 AND NOT(x6..x0) | First 1 at position 7 |
+| pZ | NOT(x7..x0) | All zeros |
+
+**Step 2: Encode position to binary**
+
+- c0 = p1 OR p3 OR p5 OR p7 (odd positions)
+- c1 = p2 OR p3 OR p6 OR p7 (positions 2,3,6,7)
+- c2 = p4 OR p5 OR p6 OR p7 (positions 4-7)
+- c3 = pZ (all zeros → count = 8)
+
+## Architecture
+
+| Layer | Components | Function |
+|-------|------------|----------|
+| 1 | 8 position detectors | Find first 1 |
+| 2 | Zero detector | All zeros? |
+| 3 | 4 OR gates | Encode to binary |
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 8 |
+| Outputs | 4 |
+| Neurons | 13 |
+| Layers | 3 |
+| Parameters | 85 |
+| Magnitude | 52 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def ctz8(bits):
+    # bits = [x0, x1, x2, x3, x4, x5, x6, x7] (LSB first)
+    inp = torch.tensor([float(b) for b in bits])
+
+    c0 = int((inp @ w['c0.weight'].T + w['c0.bias'] >= 0).item())
+    c1 = int((inp @ w['c1.weight'].T + w['c1.bias'] >= 0).item())
+    c2 = int((inp @ w['c2.weight'].T + w['c2.bias'] >= 0).item())
+    c3 = int((inp @ w['c3.weight'].T + w['c3.bias'] >= 0).item())
+
+    return c3, c2, c1, c0
+
+# Examples
+print(ctz8([1,0,0,0,0,0,0,0]))  # (0,0,0,0) = 0 trailing zeros
+print(ctz8([0,0,0,0,1,0,0,0]))  # (0,1,0,0) = 4 trailing zeros
+print(ctz8([0,0,0,0,0,0,0,0]))  # (1,0,0,0) = 8 trailing zeros (all zero)
+```
+
+## Applications
+
+- Finding alignment in memory addresses
+- Bit manipulation in compression algorithms
+- Finding least significant set bit
+- Integer factorization (powers of 2)
+- Loop optimization
+
+## Related Circuits
+
+- `threshold-clz8`: Count leading zeros (mirror operation)
+- `threshold-ffs8`: Find first set (similar, 1-indexed)
+- `threshold-priorityencoder8`: Finds MSB position instead
+
+## Files
+
+```
+threshold-ctz8/
+├── model.safetensors
+├── model.py
+├── create_safetensors.py
+├── config.json
+└── README.md
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-ctz8",
+  "description": "8-bit count trailing zeros",
+  "inputs": 8,
+  "outputs": 4,
+  "neurons": 13,
+  "layers": 3,
+  "parameters": 85
+}

create_safetensors.py

@@ -0,0 +1,139 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+# 8-bit Count Trailing Zeros (CTZ)
+# Input: x0..x7 (x0 is LSB)
+# Output: c3,c2,c1,c0 where count = 8*c3 + 4*c2 + 2*c1 + c0
+#
+# Strategy: Direct computation using threshold logic
+# For each output bit, compute based on which positions would produce that bit
+#
+# CTZ values and their binary encoding:
+# CTZ=0: 0000 (x0=1)
+# CTZ=1: 0001 (x0=0, x1=1)
+# CTZ=2: 0010 (x0=x1=0, x2=1)
+# CTZ=3: 0011 (x0=x1=x2=0, x3=1)
+# CTZ=4: 0100 (x0..x3=0, x4=1)
+# CTZ=5: 0101 (x0..x4=0, x5=1)
+# CTZ=6: 0110 (x0..x5=0, x6=1)
+# CTZ=7: 0111 (x0..x6=0, x7=1)
+# CTZ=8: 1000 (all zeros)
+
+# We need to detect the first set bit position
+# p_i = x_i AND NOT(x_{i-1}) AND ... AND NOT(x_0)
+
+# For c0 (LSB of count): 1 when CTZ is 1,3,5,7
+# c0 fires when first 1 is at position 1,3,5,7
+
+# For c1: 1 when CTZ is 2,3,6,7
+# For c2: 1 when CTZ is 4,5,6,7
+# For c3: 1 when CTZ is 8 (all zeros)
+
+# Direct threshold implementation:
+# First, detect each position's "first set" condition
+# p0 = x0 >= 1 (x0 is set)
+# p1 = x1 - x0 >= 1 (x1 set, x0 not set)
+# p2 = x2 - x1 - x0 >= 1 (x2 set, x1,x0 not set)
+# etc.
+
+# Then combine for output bits
+
+# Actually, let's use a simpler threshold approach:
+# c0 should be 1 when the first 1 is at an odd position (1,3,5,7)
+# This happens when: (x1 AND NOT x0) OR (x3 AND NOT x2 AND NOT x1 AND NOT x0) OR ...
+
+# Let's detect position of first 1:
+# If x0=1: count=0
+# If x0=0,x1=1: count=1
+# etc.
+
+# Output bit c_i is 1 when the ith bit of the count is 1
+# Using weighted sums:
+
+# c0 = 1 when count in {1,3,5,7}
+# These are: x1*(1-x0) + x3*(1-x0)(1-x1)(1-x2) + x5*... + x7*...
+# Hard to do directly. Let's use layered approach.
+
+# Layer 1: Detect "first 1 at position i"
+# Layer 2: Combine to get count bits
+
+# Position detectors (fires when first 1 is at that position)
+for i in range(8):
+    # p_i fires when x_i=1 and x_0..x_{i-1} are all 0
+    # Weights: +1 on x_i, -1 on x_0..x_{i-1}
+    # Bias: -1 (need x_i=1 and no negatives to overcome)
+    w = [0.0] * 8
+    w[i] = 1.0
+    for j in range(i):
+        w[j] = -1.0
+    # For this to fire: x_i - sum(x_0..x_{i-1}) >= 1
+    # Need x_i=1 and all lower bits = 0
+    weights[f'p{i}.weight'] = torch.tensor([w], dtype=torch.float32)
+    weights[f'p{i}.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# All-zero detector (fires when all bits are 0)
+weights['pZ.weight'] = torch.tensor([[-1.0] * 8], dtype=torch.float32)
+weights['pZ.bias'] = torch.tensor([0.0], dtype=torch.float32)  # fires when sum <= 0
+
+# Output combiners
+# c0 = p1 OR p3 OR p5 OR p7 (positions with bit 0 set in count)
+# c1 = p2 OR p3 OR p6 OR p7 (positions with bit 1 set in count)
+# c2 = p4 OR p5 OR p6 OR p7 (positions with bit 2 set in count)
+# c3 = pZ (count = 8)
+
+# These are OR gates over the position signals
+# OR(a,b,c,d) fires when sum >= 1
+
+save_file(weights, 'model.safetensors')
+
+def ctz8(bits):
+    """Count trailing zeros in 8-bit input. bits[0] is LSB."""
+    inp = torch.tensor([float(b) for b in bits])
+
+    # Detect first-1 positions
+    p = []
+    for i in range(8):
+        pi = int((inp @ weights[f'p{i}.weight'].T + weights[f'p{i}.bias'] >= 0).item())
+        p.append(pi)
+
+    pZ = int((inp @ weights['pZ.weight'].T + weights['pZ.bias'] >= 0).item())
+
+    # Combine for output bits
+    c0 = 1 if (p[1] or p[3] or p[5] or p[7]) else 0
+    c1 = 1 if (p[2] or p[3] or p[6] or p[7]) else 0
+    c2 = 1 if (p[4] or p[5] or p[6] or p[7]) else 0
+    c3 = pZ
+
+    return c3, c2, c1, c0
+
+print("Verifying ctz8...")
+errors = 0
+for i in range(256):
+    bits = [(i >> j) & 1 for j in range(8)]
+    c3, c2, c1, c0 = ctz8(bits)
+    result = 8*c3 + 4*c2 + 2*c1 + c0
+
+    # Compute expected CTZ
+    if i == 0:
+        expected = 8
+    else:
+        expected = 0
+        temp = i
+        while (temp & 1) == 0:
+            expected += 1
+            temp >>= 1
+
+    if result != expected:
+        errors += 1
+        if errors <= 5:
+            print(f"ERROR: ctz8({i:08b}) = {result}, expected {expected}")
+
+if errors == 0:
+    print("All 256 test cases passed!")
+else:
+    print(f"FAILED: {errors} errors")
+
+print(f"Magnitude: {sum(t.abs().sum().item() for t in weights.values()):.0f}")
+print(f"Parameters: {sum(t.numel() for t in weights.values())}")

model.py

@@ -0,0 +1,35 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def ctz8(bits, w):
+    """Count trailing zeros in 8-bit input. bits[0] is LSB."""
+    inp = torch.tensor([float(b) for b in bits])
+
+    p = []
+    for i in range(8):
+        pi = int((inp @ w[f'p{i}.weight'].T + w[f'p{i}.bias'] >= 0).item())
+        p.append(pi)
+
+    pZ = int((inp @ w['pZ.weight'].T + w['pZ.bias'] >= 0).item())
+
+    c0 = 1 if (p[1] or p[3] or p[5] or p[7]) else 0
+    c1 = 1 if (p[2] or p[3] or p[6] or p[7]) else 0
+    c2 = 1 if (p[4] or p[5] or p[6] or p[7]) else 0
+    c3 = pZ
+
+    return c3, c2, c1, c0
+
+if __name__ == '__main__':
+    w = load_model()
+    print('CTZ8 selected tests:')
+    print('Input    | CTZ | c3c2c1c0')
+    print('---------+-----+---------')
+    test_vals = [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00, 0x06, 0xF0, 0xFF]
+    for val in test_vals:
+        bits = [(val >> j) & 1 for j in range(8)]
+        c3, c2, c1, c0 = ctz8(bits, w)
+        count = 8*c3 + 4*c2 + 2*c1 + c0
+        print(f'{val:08b} |  {count}  | {c3}{c2}{c1}{c0}')

model.safetensors

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