Upload folder using huggingface_hub

README.md

@@ -0,0 +1,155 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- arithmetic
+---
+
+# threshold-fullsubtractor
+
+Subtracts three 1-bit inputs (a, b, borrow_in), producing difference and borrow_out. The subtraction counterpart to the full adder.
+
+## Circuit
+
+```
+        a       b
+        │       │
+        └───┬───┘
+            ▼
+       ┌─────────┐
+       │   HS1   │  First half subtractor
+       └─────────┘
+        │       │
+       d1       b1
+        │        \
+        │   bin   \
+        └──┬──┘    \
+           ▼        \
+      ┌─────────┐    \
+      │   HS2   │     │
+      └─────────┘     │
+       │       │      │
+      diff     b2     │
+               │      │
+               └──┬───┘
+                  ▼
+              ┌──────┐
+              │  OR  │
+              └──────┘
+                  │
+                  ▼
+                bout
+```
+
+## Half Subtractor Detail
+
+```
+      x       y
+      │       │
+      ├───┬───┤
+      │   │   │
+      ▼   │   ▼
+  ┌──────┐│┌──────┐           ┌───────┐
+  │  OR  │││ NAND │           │ ¬x ∧ y│
+  │w:1,1 │││w:-1,-1│          │w:-1,1 │
+  │b: -1 │││b: +1 │           │b: -1  │
+  └──────┘│└──────┘           └───────┘
+      │   │   │                   │
+      └───┼───┘                   │
+          ▼                       │
+      ┌──────┐                    │
+      │ AND  │                    │
+      └──────┘                    │
+          │                       │
+          ▼                       ▼
+        diff                   borrow
+```
+
+## Truth Table
+
+| a | b | bin | diff | bout |
+|---|---|-----|------|------|
+| 0 | 0 | 0 | 0 | 0 |
+| 0 | 0 | 1 | 1 | 1 |
+| 0 | 1 | 0 | 1 | 1 |
+| 0 | 1 | 1 | 0 | 1 |
+| 1 | 0 | 0 | 1 | 0 |
+| 1 | 0 | 1 | 0 | 0 |
+| 1 | 1 | 0 | 0 | 0 |
+| 1 | 1 | 1 | 1 | 1 |
+
+Binary: a - b - bin = diff - (bout × 2)
+
+## Composition
+
+```
+d1, b1 = HalfSubtractor(a, b)
+diff, b2 = HalfSubtractor(d1, bin)
+bout = OR(b1, b2)
+```
+
+A borrow propagates if either half subtractor produces one.
+
+## Architecture
+
+| Component | Neurons |
+|-----------|---------|
+| HS1 (a - b) | 4 |
+| HS2 (d1 - bin) | 4 |
+| OR (b1, b2) | 1 |
+
+**Total: 9 neurons, 27 parameters, 4 layers**
+
+## Contrast with Full Adder
+
+| Circuit | Carry/Borrow | HS function |
+|---------|--------------|-------------|
+| FullAdder | cout = OR(c1, c2) | c = a AND b |
+| FullSubtractor | bout = OR(b1, b2) | b = NOT(a) AND b |
+
+The only structural difference: the borrow circuit uses NOT(a) AND b instead of AND.
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def full_subtractor(a, b, bin_in):
+    inp = torch.tensor([float(a), float(b)])
+
+    # HS1
+    hs1_l1 = (inp @ w['hs1.xor.layer1.weight'].T + w['hs1.xor.layer1.bias'] >= 0).float()
+    d1 = (hs1_l1 @ w['hs1.xor.layer2.weight'].T + w['hs1.xor.layer2.bias'] >= 0).float().item()
+    b1 = (inp @ w['hs1.borrow.weight'].T + w['hs1.borrow.bias'] >= 0).float().item()
+
+    # HS2
+    inp2 = torch.tensor([d1, float(bin_in)])
+    hs2_l1 = (inp2 @ w['hs2.xor.layer1.weight'].T + w['hs2.xor.layer1.bias'] >= 0).float()
+    diff = int((hs2_l1 @ w['hs2.xor.layer2.weight'].T + w['hs2.xor.layer2.bias'] >= 0).item())
+    b2 = (inp2 @ w['hs2.borrow.weight'].T + w['hs2.borrow.bias'] >= 0).float().item()
+
+    # Final borrow
+    bout = int((torch.tensor([b1, b2]) @ w['bout.weight'].T + w['bout.bias'] >= 0).item())
+
+    return diff, bout
+```
+
+## Files
+
+```
+threshold-fullsubtractor/
+├── model.safetensors
+├── model.py
+├── config.json
+└── README.md
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-fullsubtractor",
+  "description": "Full subtractor as threshold circuit",
+  "inputs": 3,
+  "outputs": 2,
+  "neurons": 9,
+  "layers": 4,
+  "parameters": 27
+}

model.py

@@ -0,0 +1,36 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def full_subtractor(a, b, bin_in, weights):
+    """Full subtractor: computes a - b - bin, returns (diff, borrow_out)"""
+    inp = torch.tensor([float(a), float(b)])
+
+    # HS1: a - b -> d1, b1
+    hs1_l1 = (inp @ weights['hs1.xor.layer1.weight'].T + weights['hs1.xor.layer1.bias'] >= 0).float()
+    d1 = (hs1_l1 @ weights['hs1.xor.layer2.weight'].T + weights['hs1.xor.layer2.bias'] >= 0).float().item()
+    b1 = (inp @ weights['hs1.borrow.weight'].T + weights['hs1.borrow.bias'] >= 0).float().item()
+
+    # HS2: d1 - bin -> diff, b2
+    inp2 = torch.tensor([d1, float(bin_in)])
+    hs2_l1 = (inp2 @ weights['hs2.xor.layer1.weight'].T + weights['hs2.xor.layer1.bias'] >= 0).float()
+    diff = int((hs2_l1 @ weights['hs2.xor.layer2.weight'].T + weights['hs2.xor.layer2.bias'] >= 0).item())
+    b2 = (inp2 @ weights['hs2.borrow.weight'].T + weights['hs2.borrow.bias'] >= 0).float().item()
+
+    # Final borrow: OR(b1, b2)
+    bout_inp = torch.tensor([b1, b2])
+    bout = int((bout_inp @ weights['bout.weight'].T + weights['bout.bias'] >= 0).item())
+
+    return diff, bout
+
+if __name__ == '__main__':
+    w = load_model()
+    print('FullSubtractor truth table:')
+    print('a b bin | diff bout')
+    for a in [0, 1]:
+        for b in [0, 1]:
+            for bin_in in [0, 1]:
+                diff, bout = full_subtractor(a, b, bin_in, w)
+                print(f'{a} {b}  {bin_in}  |  {diff}    {bout}')

model.safetensors

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