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

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