Upload folder using huggingface_hub

README.md

@@ -0,0 +1,117 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- arithmetic
+---
+
+# threshold-halfsubtractor
+
+Subtracts two 1-bit inputs, producing difference and borrow. The subtraction counterpart to the half adder.
+
+## Circuit
+
+```
+      a       b                    a   b
+      │       │                    │   │
+      ├───┬───┤                    └─┬─┘
+      │   │   │                      │
+      ▼   │   ▼                      ▼
+  ┌──────┐│┌──────┐              ┌───────┐
+  │  OR  │││ NAND │              │ ¬a ∧ b│
+  │w:1,1 │││w:-1,-1│             │w:-1,1 │
+  │b: -1 │││b: +1 │              │b: -1  │
+  └──────┘│└──────┘              └───────┘
+      │   │   │                      │
+      └───┼───┘                      │
+          ▼                          │
+      ┌──────┐                       │
+      │ AND  │                       │
+      │w: 1,1│                       │
+      │b: -2 │                       │
+      └──────┘                       │
+          │                          │
+          ▼                          ▼
+        diff                      borrow
+```
+
+The diff output uses XOR (2 layers). The borrow output detects when we subtract 1 from 0.
+
+## Truth Table
+
+| a | b | diff | borrow |
+|---|---|------|--------|
+| 0 | 0 | 0 | 0 |
+| 0 | 1 | 1 | 1 |
+| 1 | 0 | 1 | 0 |
+| 1 | 1 | 0 | 0 |
+
+Binary: a - b = diff - (borrow × 2)
+
+## Mechanism
+
+**Diff (XOR):** Same as the half adder's sum. The difference bit is 1 when exactly one input is 1.
+
+**Borrow:** Uses weights [-1, +1] with bias -1. This fires only when a=0 and b=1:
+- a=0, b=0: -0 + 0 - 1 = -1 < 0 → no borrow
+- a=0, b=1: -0 + 1 - 1 = 0 ≥ 0 → borrow
+- a=1, b=0: -1 + 0 - 1 = -2 < 0 → no borrow
+- a=1, b=1: -1 + 1 - 1 = -1 < 0 → no borrow
+
+The borrow is NOT(a) AND b - we borrow when subtracting 1 from 0.
+
+## Components
+
+| Output | Function | Neurons | Layers |
+|--------|----------|---------|--------|
+| diff | XOR(a, b) | 3 | 2 |
+| borrow | ¬a ∧ b | 1 | 1 |
+
+**Total: 4 neurons, 12 parameters**
+
+## Contrast with Half Adder
+
+| Circuit | Output 2 | Function | Weights |
+|---------|----------|----------|---------|
+| HalfAdder | carry | a ∧ b | [1, 1], b=-2 |
+| HalfSubtractor | borrow | ¬a ∧ b | [-1, 1], b=-1 |
+
+The only difference: borrow has an inhibitory weight on a.
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def half_subtractor(a, b):
+    inp = torch.tensor([float(a), float(b)])
+
+    # XOR for diff
+    l1 = (inp @ w['xor.layer1.weight'].T + w['xor.layer1.bias'] >= 0).float()
+    diff = int((l1 @ w['xor.layer2.weight'].T + w['xor.layer2.bias'] >= 0).item())
+
+    # Borrow
+    borrow = int((inp @ w['borrow.weight'].T + w['borrow.bias'] >= 0).item())
+
+    return diff, borrow
+```
+
+## Files
+
+```
+threshold-halfsubtractor/
+├── model.safetensors
+├── model.py
+├── config.json
+└── README.md
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-halfsubtractor",
+  "description": "Half subtractor as threshold circuit",
+  "inputs": 2,
+  "outputs": 2,
+  "neurons": 4,
+  "layers": 2,
+  "parameters": 12
+}

model.py

@@ -0,0 +1,23 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def half_subtractor(a, b, weights):
+    """Half subtractor: computes a - b, returns (diff, borrow)"""
+    inp = torch.tensor([float(a), float(b)])
+    # XOR for diff
+    l1 = (inp @ weights['xor.layer1.weight'].T + weights['xor.layer1.bias'] >= 0).float()
+    diff = int((l1 @ weights['xor.layer2.weight'].T + weights['xor.layer2.bias'] >= 0).item())
+    # Borrow
+    borrow = int((inp @ weights['borrow.weight'].T + weights['borrow.bias'] >= 0).item())
+    return diff, borrow
+
+if __name__ == '__main__':
+    w = load_model()
+    print('HalfSubtractor truth table:')
+    for a in [0, 1]:
+        for b in [0, 1]:
+            diff, borrow = half_subtractor(a, b, w)
+            print(f'{a} - {b} = {diff}, borrow={borrow}')

model.safetensors

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