Signed addition overflow detector, magnitude 12

README.md

@@ -0,0 +1,81 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+---
+
+# threshold-overflowdetect
+
+Detect signed addition overflow from sign bits of operands and result.
+
+## Function
+
+overflow(a_sign, b_sign, sum_sign) = 1 if overflow occurred
+
+In 2's complement addition, overflow occurs when:
+- Two positive numbers produce a negative result
+- Two negative numbers produce a positive result
+
+## Truth Table
+
+| a_sign | b_sign | sum_sign | overflow | meaning |
+|:------:|:------:|:--------:|:--------:|---------|
+| 0 | 0 | 0 | 0 | pos + pos = pos (ok) |
+| 0 | 0 | 1 | 1 | pos + pos = neg (OVERFLOW) |
+| 0 | 1 | 0 | 0 | pos + neg = pos (ok) |
+| 0 | 1 | 1 | 0 | pos + neg = neg (ok) |
+| 1 | 0 | 0 | 0 | neg + pos = pos (ok) |
+| 1 | 0 | 1 | 0 | neg + pos = neg (ok) |
+| 1 | 1 | 0 | 1 | neg + neg = pos (OVERFLOW) |
+| 1 | 1 | 1 | 0 | neg + neg = neg (ok) |
+
+## Architecture
+
+2-layer circuit detecting both overflow cases:
+
+**Layer 1:**
+- N1: detects positive overflow (0,0,1) - weights [-1,-1,+1], bias -1
+- N2: detects negative overflow (1,1,0) - weights [+1,+1,-1], bias -2
+
+**Layer 2:**
+- OR gate: weights [1,1], bias -1
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 3 |
+| Outputs | 1 |
+| Neurons | 3 |
+| Layers | 2 |
+| Parameters | 11 |
+| Magnitude | 12 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def overflow_detect(a_sign, b_sign, sum_sign):
+    inp = torch.tensor([float(a_sign), float(b_sign), float(sum_sign)])
+    n1 = int((inp @ w['layer1.n1.weight'].T + w['layer1.n1.bias'] >= 0).item())
+    n2 = int((inp @ w['layer1.n2.weight'].T + w['layer1.n2.bias'] >= 0).item())
+    hidden = torch.tensor([float(n1), float(n2)])
+    return int((hidden @ w['layer2.weight'].T + w['layer2.bias'] >= 0).item())
+
+# Example: 5 + 4 = 9, but in 4-bit signed: 0101 + 0100 = 1001 = -7
+print(overflow_detect(0, 0, 1))  # 1 (overflow!)
+
+# Example: -3 + 2 = -1 (no overflow)
+print(overflow_detect(1, 0, 1))  # 0 (ok)
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-overflowdetect",
+  "description": "Detect signed addition overflow from sign bits",
+  "inputs": 3,
+  "outputs": 1,
+  "neurons": 3,
+  "layers": 2,
+  "parameters": 11
+}

create_safetensors.py

@@ -0,0 +1,43 @@
+import torch
+from safetensors.torch import save_file
+
+# Inputs: a_sign, b_sign, sum_sign
+# Overflow occurs when:
+#   - Two positives produce negative: a=0, b=0, s=1
+#   - Two negatives produce positive: a=1, b=1, s=0
+
+weights = {
+    # N1: detects (0,0,1) - positive overflow
+    'layer1.n1.weight': torch.tensor([[-1.0, -1.0, 1.0]], dtype=torch.float32),
+    'layer1.n1.bias': torch.tensor([-1.0], dtype=torch.float32),
+    # N2: detects (1,1,0) - negative overflow
+    'layer1.n2.weight': torch.tensor([[1.0, 1.0, -1.0]], dtype=torch.float32),
+    'layer1.n2.bias': torch.tensor([-2.0], dtype=torch.float32),
+    # Layer 2: OR gate
+    'layer2.weight': torch.tensor([[1.0, 1.0]], dtype=torch.float32),
+    'layer2.bias': torch.tensor([-1.0], dtype=torch.float32)
+}
+save_file(weights, 'model.safetensors')
+
+def overflow_detect(a_sign, b_sign, sum_sign):
+    inp = torch.tensor([float(a_sign), float(b_sign), float(sum_sign)])
+    n1 = int((inp @ weights['layer1.n1.weight'].T + weights['layer1.n1.bias'] >= 0).item())
+    n2 = int((inp @ weights['layer1.n2.weight'].T + weights['layer1.n2.bias'] >= 0).item())
+    hidden = torch.tensor([float(n1), float(n2)])
+    return int((hidden @ weights['layer2.weight'].T + weights['layer2.bias'] >= 0).item())
+
+print("Verifying overflowdetect...")
+errors = 0
+for a in [0, 1]:
+    for b in [0, 1]:
+        for s in [0, 1]:
+            result = overflow_detect(a, b, s)
+            # Overflow when signs of operands match but sum sign differs
+            expected = 1 if (a == b) and (a != s) else 0
+            if result != expected:
+                errors += 1
+                print(f"ERROR: a={a}, b={b}, s={s} -> {result}, expected {expected}")
+
+if errors == 0:
+    print("All 8 test cases passed!")
+print(f"Magnitude: {sum(t.abs().sum().item() for t in weights.values()):.0f}")

model.py

@@ -0,0 +1,28 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def overflow_detect(a_sign, b_sign, sum_sign, weights):
+    """Detect signed addition overflow. Returns 1 if overflow occurred."""
+    inp = torch.tensor([float(a_sign), float(b_sign), float(sum_sign)])
+    n1 = int((inp @ weights['layer1.n1.weight'].T + weights['layer1.n1.bias'] >= 0).item())
+    n2 = int((inp @ weights['layer1.n2.weight'].T + weights['layer1.n2.bias'] >= 0).item())
+    hidden = torch.tensor([float(n1), float(n2)])
+    return int((hidden @ weights['layer2.weight'].T + weights['layer2.bias'] >= 0).item())
+
+if __name__ == '__main__':
+    w = load_model()
+    print('Overflow detection truth table:')
+    print('a_sign b_sign sum_sign | overflow | meaning')
+    print('-' * 55)
+    for a in [0, 1]:
+        for b in [0, 1]:
+            for s in [0, 1]:
+                result = overflow_detect(a, b, s, w)
+                a_str = 'pos' if a == 0 else 'neg'
+                b_str = 'pos' if b == 0 else 'neg'
+                s_str = 'pos' if s == 0 else 'neg'
+                marker = 'OVERFLOW!' if result else 'ok'
+                print(f'   {a}       {b}        {s}     |    {result}     | {a_str}+{b_str}={s_str} {marker}')