4x4 binary multiplier

README.md

@@ -0,0 +1,86 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- arithmetic
+- multiplier
+---
+
+# threshold-multiplier4x4
+
+4x4 binary multiplier as threshold circuit. Multiplies two 4-bit unsigned integers to produce an 8-bit product.
+
+## Circuit
+
+```
+A[3:0] ──┐
+         ├──► 4x4 MUL ──► P[7:0]
+B[3:0] ──┘
+
+P = A × B
+Range: 0-15 × 0-15 = 0-225
+```
+
+## Architecture
+
+```
+Partial Products (16 AND gates):
+        b3    b2    b1    b0
+    ×   a3    a2    a1    a0
+    ─────────────────────────
+              a0b3  a0b2  a0b1  a0b0
+        a1b3  a1b2  a1b1  a1b0
+  a2b3  a2b2  a2b1  a2b0
++ a3b3  a3b2  a3b1  a3b0
+─────────────────────────────────────
+  p7    p6    p5    p4    p3    p2    p1    p0
+```
+
+| Component | Count | Neurons |
+|-----------|-------|---------|
+| AND (partial products) | 16 | 16 |
+| Half Adders | 4 | 16 |
+| Full Adders | 8 | 56 |
+
+**Total: 88 neurons, 368 parameters, 6 layers**
+
+## Adder Tree Structure
+
+```
+Column 1: HA(pp10, pp01) → p1, c1
+Column 2: FA(pp20, pp11, pp02) → s, c
+          HA(s, c1) → p2, c
+Column 3: FA(pp30, pp21, pp12) → s, c
+          FA(s, pp03, c) → s', c'
+          HA(s', c) → p3, c
+Column 4-6: Similar carry-propagate structure
+Column 7: Final carry → p7
+```
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+
+w = load_file('model.safetensors')
+
+# Verify: 15 × 15 = 225
+# All 256 input combinations tested
+```
+
+## Files
+
+```
+threshold-multiplier4x4/
+├── model.safetensors
+├── create_safetensors.py
+├── config.json
+└── README.md
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-multiplier4x4",
+  "description": "4x4 binary multiplier as threshold circuit",
+  "inputs": 8,
+  "outputs": 8,
+  "neurons": 88,
+  "layers": 6,
+  "parameters": 368
+}

create_safetensors.py

@@ -0,0 +1,137 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+# 4x4 binary multiplier
+# Inputs: a3,a2,a1,a0, b3,b2,b1,b0 (8 inputs)
+# Outputs: p7,p6,p5,p4,p3,p2,p1,p0 (8 outputs)
+
+# Partial products: pp[i][j] = a[i] AND b[j]
+# Column c gets all pp[i][j] where i+j = c
+
+def add_and_gate(name, a_idx, b_idx, total_inputs):
+    w = [0.0] * total_inputs
+    w[a_idx] = 1.0
+    w[b_idx] = 1.0
+    weights[f'{name}.weight'] = torch.tensor([w], dtype=torch.float32)
+    weights[f'{name}.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+def add_xor_gate(name, total_inputs):
+    weights[f'{name}.or.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+    weights[f'{name}.or.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+    weights[f'{name}.nand.weight'] = torch.tensor([[-1.0, -1.0]], dtype=torch.float32)
+    weights[f'{name}.nand.bias'] = torch.tensor([1.0], dtype=torch.float32)
+    weights[f'{name}.and.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+    weights[f'{name}.and.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+def add_ha(name):
+    add_xor_gate(f'{name}.sum', 2)
+    weights[f'{name}.carry.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+    weights[f'{name}.carry.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+def add_fa(name):
+    add_xor_gate(f'{name}.xor1', 2)
+    add_xor_gate(f'{name}.sum', 2)
+    weights[f'{name}.maj.weight'] = torch.tensor([[1.0, 1.0, 1.0]], dtype=torch.float32)
+    weights[f'{name}.maj.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# Input indices: a3=0, a2=1, a1=2, a0=3, b3=4, b2=5, b1=6, b0=7
+
+# Layer 1: 16 AND gates for partial products
+for i in range(4):
+    for j in range(4):
+        a_idx = 3 - i
+        b_idx = 7 - j
+        add_and_gate(f'pp{i}{j}', a_idx, b_idx, 8)
+
+# Adder structure for summing partial products
+add_ha('ha_c1')
+add_fa('fa_c2_0')
+add_ha('ha_c2_1')
+add_fa('fa_c3_0')
+add_fa('fa_c3_1')
+add_ha('ha_c3_2')
+add_fa('fa_c4_0')
+add_fa('fa_c4_1')
+add_ha('ha_c4_2')
+add_fa('fa_c5_0')
+add_fa('fa_c5_1')
+add_fa('fa_c6')
+
+save_file(weights, 'model.safetensors')
+
+def eval_and(a, b):
+    return int(a + b >= 2)
+
+def eval_xor(a, b):
+    or_out = int(a + b >= 1)
+    nand_out = int(-a - b + 1 >= 0)
+    return int(or_out + nand_out >= 2)
+
+def eval_ha(a, b):
+    s = eval_xor(a, b)
+    c = eval_and(a, b)
+    return s, c
+
+def eval_fa(a, b, cin):
+    x1 = eval_xor(a, b)
+    s = eval_xor(x1, cin)
+    c = int(a + b + cin >= 2)
+    return s, c
+
+def multiply_4x4(a3, a2, a1, a0, b3, b2, b1, b0):
+    pp = [[eval_and([a0,a1,a2,a3][i], [b0,b1,b2,b3][j]) for j in range(4)] for i in range(4)]
+
+    p0 = pp[0][0]
+
+    s1, c1 = eval_ha(pp[1][0], pp[0][1])
+    p1 = s1
+
+    s2_0, c2_0 = eval_fa(pp[2][0], pp[1][1], pp[0][2])
+    s2_1, c2_1 = eval_ha(s2_0, c1)
+    p2 = s2_1
+
+    s3_0, c3_0 = eval_fa(pp[3][0], pp[2][1], pp[1][2])
+    s3_1, c3_1 = eval_fa(s3_0, pp[0][3], c2_0)
+    s3_2, c3_2 = eval_ha(s3_1, c2_1)
+    p3 = s3_2
+
+    s4_0, c4_0 = eval_fa(pp[3][1], pp[2][2], pp[1][3])
+    s4_1, c4_1 = eval_fa(s4_0, c3_0, c3_1)
+    s4_2, c4_2 = eval_ha(s4_1, c3_2)
+    p4 = s4_2
+
+    s5_0, c5_0 = eval_fa(pp[3][2], pp[2][3], c4_0)
+    s5_1, c5_1 = eval_fa(s5_0, c4_1, c4_2)
+    p5 = s5_1
+
+    s6, c6 = eval_fa(pp[3][3], c5_0, c5_1)
+    p6 = s6
+
+    p7 = c6
+
+    return p0, p1, p2, p3, p4, p5, p6, p7
+
+print("Verifying 4x4 multiplier...")
+errors = 0
+for a in range(16):
+    for b in range(16):
+        a3, a2, a1, a0 = (a>>3)&1, (a>>2)&1, (a>>1)&1, a&1
+        b3, b2, b1, b0 = (b>>3)&1, (b>>2)&1, (b>>1)&1, b&1
+        p = multiply_4x4(a3, a2, a1, a0, b3, b2, b1, b0)
+        result = sum(p[i] << i for i in range(8))
+        expected = a * b
+        if result != expected:
+            errors += 1
+            if errors <= 5:
+                print(f"ERROR: {a} * {b} = {result}, expected {expected}")
+
+if errors == 0:
+    print("All 256 test cases passed!")
+else:
+    print(f"FAILED: {errors} errors")
+
+mag = sum(t.abs().sum().item() for t in weights.values())
+print(f"Magnitude: {mag:.0f}")
+print(f"Parameters: {sum(t.numel() for t in weights.values())}")