Upload folder using huggingface_hub

README.md

@@ -0,0 +1,130 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- decoder
+---
+
+# threshold-thermometertobinary
+
+Converts 7-bit thermometer code to 3-bit binary. The inverse of BinaryToThermometer.
+
+## Circuit
+
+```
+  t₀  t₁  t₂  t₃  t₄  t₅  t₆
+   │   │   │   │   │   │   │
+   │   │   │   │   │   │   │
+   ├───┴───┴───┴───┴───┴───┘
+   │   │       │       │
+   │   ├───────┼───────┼──────────► b₂ (direct from t₃)
+   │   │       │       │
+   │   │   ┌───┴───┐   │
+   │   │   │t₁∧¬t₃ │   │
+   │   │   └───┬───┘   │
+   │   │       │       │
+   │   │       ├───OR──┴──────────► b₁
+   │   │       │   │
+   │   │       │   t₅
+   │   │       │
+   ├───┴───┐ ┌─┴─┐ ┌───┐
+   │t₀∧¬t₁│ │...│ │t₆ │
+   └───┬───┘ └─┬─┘ └─┬─┘
+       │       │     │
+       └───────┴─OR──┴────────────► b₀
+```
+
+## Conversion Table
+
+| Thermometer | Value | Binary |
+|-------------|-------|--------|
+| 0000000 | 0 | 000 |
+| 1000000 | 1 | 001 |
+| 1100000 | 2 | 010 |
+| 1110000 | 3 | 011 |
+| 1111000 | 4 | 100 |
+| 1111100 | 5 | 101 |
+| 1111110 | 6 | 110 |
+| 1111111 | 7 | 111 |
+
+## Mechanism
+
+For valid thermometer (monotonic ones then zeros), tᵢ = 1 iff value > i.
+
+**b₂ (bit 2)**: Directly equals t₃.
+- t₃ = 1 iff value ≥ 4, which is exactly when b₂ = 1
+
+**b₁ (bit 1)**: Fires for values {2, 3, 6, 7}.
+```
+b₁ = (t₁ AND NOT(t₃)) OR t₅
+```
+- t₁ AND NOT(t₃) catches values 2, 3 (≥2 but <4)
+- t₅ catches values 6, 7 (≥6)
+
+**b₀ (bit 0)**: Fires for odd values {1, 3, 5, 7}.
+```
+b₀ = (t₀ AND NOT(t₁)) OR (t₂ AND NOT(t₃)) OR (t₄ AND NOT(t₅)) OR t₆
+```
+Each AND-NOT term detects a transition from 1 to 0 at an odd position.
+
+## The Transition Detection Insight
+
+In valid thermometer code, the value equals the position of the last 1. The formula detects "where does the thermometer stop?"
+
+| Value | Last 1 at | Detected by |
+|-------|-----------|-------------|
+| 1 | t₀ | t₀ AND NOT(t₁) |
+| 3 | t₂ | t₂ AND NOT(t₃) |
+| 5 | t₄ | t₄ AND NOT(t₅) |
+| 7 | t₆ | t₆ (no t₇ to check) |
+
+## Architecture
+
+| Output | Neurons | Parameters |
+|--------|---------|------------|
+| b₂ | 1 | 8 |
+| b₁ | 2 | 11 |
+| b₀ | 4 | 29 |
+| **Total** | **7** | **48** |
+
+**Layers: 2**
+
+## Asymmetry Note
+
+BinaryToThermometer is single-layer (7 parallel thresholds). ThermometerToBinary requires 2 layers because extracting individual bits from a sum needs non-trivial logic.
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def therm_to_binary(therm):
+    """therm: 7-element list"""
+    # See model.py for full implementation
+    pass
+
+# Thermometer for 5 -> binary 101
+therm = [1, 1, 1, 1, 1, 0, 0]
+b2, b1, b0 = therm_to_binary(therm)
+print(b2, b1, b0)  # 1, 0, 1
+```
+
+## Files
+
+```
+threshold-thermometertobinary/
+├── model.safetensors
+├── model.py
+├── config.json
+└── README.md
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-thermometertobinary",
+  "description": "7-bit thermometer to 3-bit binary converter",
+  "inputs": 7,
+  "outputs": 3,
+  "neurons": 7,
+  "layers": 2,
+  "parameters": 48
+}

model.py

@@ -0,0 +1,39 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def thermometer_to_binary(therm, weights):
+    """Convert 7-bit thermometer to 3-bit binary.
+    Returns (b2, b1, b0).
+    """
+    t = torch.tensor([float(x) for x in therm])
+
+    # b2 = t3 (direct)
+    b2 = int((t * weights['b2.weight']).sum() + weights['b2.bias'] >= 0)
+
+    # b1 = (t1 AND NOT(t3)) OR t5
+    and_result = int((t * weights['b1_and.weight']).sum() + weights['b1_and.bias'] >= 0)
+    b1_inputs = torch.tensor([float(and_result), float(therm[5])])
+    b1 = int((b1_inputs * weights['b1_or.weight']).sum() + weights['b1_or.bias'] >= 0)
+
+    # b0 = (t0 AND NOT(t1)) OR (t2 AND NOT(t3)) OR (t4 AND NOT(t5)) OR t6
+    and0 = int((t * weights['b0_and0.weight']).sum() + weights['b0_and0.bias'] >= 0)
+    and2 = int((t * weights['b0_and2.weight']).sum() + weights['b0_and2.bias'] >= 0)
+    and4 = int((t * weights['b0_and4.weight']).sum() + weights['b0_and4.bias'] >= 0)
+    b0_inputs = torch.tensor([float(and0), float(and2), float(and4), float(therm[6])])
+    b0 = int((b0_inputs * weights['b0_or.weight']).sum() + weights['b0_or.bias'] >= 0)
+
+    return b2, b1, b0
+
+if __name__ == '__main__':
+    w = load_model()
+    print('Thermometer to Binary Converter')
+    thermometers = [
+        [0,0,0,0,0,0,0], [1,0,0,0,0,0,0], [1,1,0,0,0,0,0], [1,1,1,0,0,0,0],
+        [1,1,1,1,0,0,0], [1,1,1,1,1,0,0], [1,1,1,1,1,1,0], [1,1,1,1,1,1,1],
+    ]
+    for therm in thermometers:
+        b2, b1, b0 = thermometer_to_binary(therm, w)
+        print(f"{''.join(map(str,therm))} -> {b2*4 + b1*2 + b0}")

model.safetensors

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