4-bit ALU

README.md

@@ -0,0 +1,90 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- arithmetic
+- alu
+---
+
+# threshold-alu4bit
+
+4-bit Arithmetic Logic Unit as threshold circuit. Performs arithmetic and bitwise operations on two 4-bit operands.
+
+## Circuit
+
+```
+A[3:0]  ──┐
+B[3:0]  ──┼──► ALU ──┬──► R[3:0]  (result)
+op[1:0] ──┘         ├──► Cout    (carry out)
+                    └──► Zero    (zero flag)
+```
+
+## Operations
+
+| op | Operation | Description |
+|----|-----------|-------------|
+| 00 | ADD | R = A + B |
+| 01 | SUB | R = A - B (2's complement) |
+| 10 | AND | R = A & B |
+| 11 | XOR | R = A ^ B |
+
+## Flags
+
+- **Cout**: Carry out from addition, borrow (inverted) from subtraction
+- **Zero**: Set when result is 0
+
+## Architecture
+
+| Component | Count | Neurons |
+|-----------|-------|---------|
+| Full Adders | 4 | 28 |
+| B XOR (for SUB) | 4 | 12 |
+| Bitwise AND | 4 | 4 |
+| Bitwise XOR | 4 | 12 |
+| Output MUX4 | 4 | 20 |
+| Zero detect | 1 | 1 |
+| Cout MUX | 1 | 5 |
+
+**Total: 82 neurons, 282 parameters, 5 layers**
+
+## How Subtraction Works
+
+```
+A - B = A + (~B) + 1  (2's complement)
+
+When op=01:
+- B bits are XORed with 1 (inverted)
+- Carry-in is set to 1
+- Result is A - B
+```
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+
+w = load_file('model.safetensors')
+
+# Examples:
+# op=0: 5 + 3 = 8, cout=0, zero=0
+# op=1: 5 - 3 = 2, cout=1, zero=0
+# op=2: 5 & 3 = 1, cout=0, zero=0
+# op=3: 5 ^ 3 = 6, cout=0, zero=0
+```
+
+## Files
+
+```
+threshold-alu4bit/
+├── model.safetensors
+├── create_safetensors.py
+├── config.json
+└── README.md
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-alu4bit",
+  "description": "4-bit ALU with ADD, SUB, AND, XOR operations",
+  "inputs": 10,
+  "outputs": 6,
+  "neurons": 82,
+  "layers": 5,
+  "parameters": 282
+}

create_safetensors.py

@@ -0,0 +1,156 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+# 4-bit ALU
+# Inputs: a3,a2,a1,a0, b3,b2,b1,b0, op1,op0 (10 inputs)
+# Outputs: r3,r2,r1,r0, cout, zero (6 outputs)
+#
+# Operations:
+#   00: ADD (A + B)
+#   01: SUB (A - B, using 2's complement)
+#   10: AND (A & B)
+#   11: XOR (A ^ B)
+
+def add_xor(name):
+    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_fa(name):
+    add_xor(f'{name}.xor1')
+    add_xor(f'{name}.sum')
+    weights[f'{name}.carry.weight'] = torch.tensor([[1.0, 1.0, 1.0]], dtype=torch.float32)
+    weights[f'{name}.carry.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+def add_and(name, n=2):
+    weights[f'{name}.weight'] = torch.tensor([[1.0] * n], dtype=torch.float32)
+    weights[f'{name}.bias'] = torch.tensor([-float(n)], dtype=torch.float32)
+
+def add_or(name, n=2):
+    weights[f'{name}.weight'] = torch.tensor([[1.0] * n], dtype=torch.float32)
+    weights[f'{name}.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+def add_mux4(name):
+    for sel in range(4):
+        s1 = (sel >> 1) & 1
+        s0 = sel & 1
+        w_s1 = 1.0 if s1 else -1.0
+        w_s0 = 1.0 if s0 else -1.0
+        bias = -(1 + bin(sel).count('1'))
+        weights[f'{name}.sel{sel}.weight'] = torch.tensor([[1.0, w_s1, w_s0]], dtype=torch.float32)
+        weights[f'{name}.sel{sel}.bias'] = torch.tensor([bias], dtype=torch.float32)
+    weights[f'{name}.or.weight'] = torch.tensor([[1.0, 1.0, 1.0, 1.0]], dtype=torch.float32)
+    weights[f'{name}.or.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# Adder/Subtractor (4 FAs)
+for i in range(4):
+    add_fa(f'addsub.fa{i}')
+
+# B XOR for subtraction (complement B when subtracting)
+for i in range(4):
+    add_xor(f'bxor{i}')
+
+# Bitwise AND
+for i in range(4):
+    add_and(f'band{i}')
+
+# Bitwise XOR
+for i in range(4):
+    add_xor(f'bxor_op{i}')
+
+# Output MUX for each bit (select from 4 operations)
+for i in range(4):
+    add_mux4(f'mux{i}')
+
+# Zero flag: NOR of all result bits
+weights['zero.weight'] = torch.tensor([[-1.0, -1.0, -1.0, -1.0]], dtype=torch.float32)
+weights['zero.bias'] = torch.tensor([0.0], dtype=torch.float32)
+
+# Cout MUX (only valid for ADD/SUB)
+add_mux4('cout_mux')
+
+save_file(weights, 'model.safetensors')
+
+def eval_xor(a, b):
+    return int((a or b) and not (a and b))
+
+def eval_fa(a, b, cin):
+    s = eval_xor(eval_xor(a, b), cin)
+    c = int(a + b + cin >= 2)
+    return s, c
+
+def alu_4bit(a, b, op):
+    a_bits = [(a >> i) & 1 for i in range(4)]
+    b_bits = [(b >> i) & 1 for i in range(4)]
+    op1, op0 = (op >> 1) & 1, op & 1
+
+    sub_mode = (op == 1)
+    b_mod = [eval_xor(b_bits[i], sub_mode) for i in range(4)]
+    cin = sub_mode
+
+    add_result = []
+    c = cin
+    for i in range(4):
+        s, c = eval_fa(a_bits[i], b_mod[i], c)
+        add_result.append(s)
+    cout = c
+
+    and_result = [a_bits[i] and b_bits[i] for i in range(4)]
+    xor_result = [eval_xor(a_bits[i], b_bits[i]) for i in range(4)]
+
+    if op == 0:
+        r = add_result
+        cout_final = cout
+    elif op == 1:
+        r = add_result
+        cout_final = cout
+    elif op == 2:
+        r = and_result
+        cout_final = 0
+    else:
+        r = xor_result
+        cout_final = 0
+
+    result = sum(r[i] << i for i in range(4))
+    zero = 1 if result == 0 else 0
+
+    return result, cout_final, zero
+
+print("Verifying 4-bit ALU...")
+errors = 0
+for a in range(16):
+    for b in range(16):
+        for op in range(4):
+            r, cout, zero = alu_4bit(a, b, op)
+            if op == 0:
+                expected = (a + b) & 0xF
+                exp_cout = 1 if (a + b) > 15 else 0
+            elif op == 1:
+                expected = (a - b) & 0xF
+                exp_cout = 1 if a >= b else 0
+            elif op == 2:
+                expected = a & b
+                exp_cout = 0
+            else:
+                expected = a ^ b
+                exp_cout = 0
+            exp_zero = 1 if expected == 0 else 0
+
+            if r != expected or zero != exp_zero:
+                errors += 1
+                if errors <= 5:
+                    print(f"ERROR: op={op}, A={a}, B={b}: got {r}, expected {expected}")
+
+if errors == 0:
+    print("All 1024 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())}")