Upload folder using huggingface_hub

README.md

@@ -0,0 +1,147 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- arithmetic
+- multiplier
+---
+
+# threshold-multiplier2x2
+
+2×2 binary multiplier. Multiplies two 2-bit numbers to produce a 4-bit product.
+
+## Circuit
+
+```
+              a1  a0
+            × b1  b0
+           ─────────
+              a1b0 a0b0      (partial products row 0)
+         a1b1 a0b1           (partial products row 1)
+        ─────────────────
+         p3   p2   p1   p0
+
+
+     a0──┬───────┬───────────────────────────────────► p0 = a0b0
+         │       │
+     b0──┼───┬───┼───┬───────────────────────────────┐
+         │   │   │   │                               │
+         ▼   │   ▼   │                               │
+      ┌─────┐│┌─────┐│                               │
+      │a0b0 │││a1b0 ││                               │
+      └─────┘│└─────┘│                               │
+             │   │   │                               │
+     a1──────┴───┼───┴───┬───────────────────────────┤
+                 │       │                           │
+     b1──────────┴───┬───┴───────────────────────────┤
+                     │   │                           │
+                     ▼   ▼                           │
+                  ┌─────┐┌─────┐                     │
+                  │a0b1 ││a1b1 │                     │
+                  └─────┘└─────┘                     │
+                     │      │                        │
+                     │      │                        │
+         a1b0────────┼──────┼────┐                   │
+                     │      │    │                   │
+         a0b1────────┴──────┼────┼────┐              │
+                            │    │    │              │
+                            │    ▼    ▼              │
+                            │  ┌────────┐            │
+                            │  │  HA    │            │
+                            │  │ p1, c1 │            │
+                            │  └────────┘            │
+                            │    │    │              │
+                            │    │    │              │
+         a1b1───────────────┴────┼────┼────┐         │
+                                 │    │    │         │
+         c1 ─────────────────────┴────┼────┼────┐    │
+                                      │    │    │    │
+                                      │    ▼    ▼    │
+                                      │  ┌────────┐  │
+                                      │  │  HA    │  │
+                                      │  │ p2, p3 │  │
+                                      │  └────────┘  │
+                                      │    │    │    │
+                                      ▼    ▼    ▼    ▼
+                                     p1   p2   p3   p0
+```
+
+## Multiplication Table
+
+| a | b | a × b |
+|---|---|-------|
+| 0 | 0 | 0 |
+| 0 | 1 | 0 |
+| 0 | 2 | 0 |
+| 0 | 3 | 0 |
+| 1 | 1 | 1 |
+| 1 | 2 | 2 |
+| 1 | 3 | 3 |
+| 2 | 2 | 4 |
+| 2 | 3 | 6 |
+| 3 | 3 | 9 |
+
+Maximum: 3 × 3 = 9 (binary 1001)
+
+## Algorithm
+
+Standard pencil-and-paper multiplication:
+
+1. **Compute partial products** (4 AND gates):
+   - a0b0, a1b0, a0b1, a1b1
+
+2. **Add column 1** (half adder):
+   - p1, c1 = HA(a1b0, a0b1)
+
+3. **Add column 2** (half adder):
+   - p2, p3 = HA(a1b1, c1)
+
+4. **Assemble result**:
+   - p0 = a0b0
+   - p1-p3 from adders
+
+## Architecture
+
+| Component | Neurons | Parameters |
+|-----------|---------|------------|
+| AND × 4 | 4 | 12 |
+| HA (p1) | 4 | 12 |
+| HA (p2) | 4 | 12 |
+| **Total** | **12** | **36** |
+
+**Layers: 5** (AND → XOR L1 → XOR L2 → XOR L1 → XOR L2)
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+
+w = load_file('model.safetensors')
+
+def multiply_2x2(a, b):
+    """a, b: 2-bit integers (0-3)
+    Returns: 4-bit product"""
+    a0, a1 = a & 1, (a >> 1) & 1
+    b0, b1 = b & 1, (b >> 1) & 1
+    # See model.py for full implementation
+    pass
+
+result = multiply_2x2(3, 3)  # Returns 9
+```
+
+## Files
+
+```
+threshold-multiplier2x2/
+├── model.safetensors
+├── model.py
+├── config.json
+└── README.md
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-multiplier2x2",
+  "description": "2x2 binary multiplier as threshold circuit",
+  "inputs": 4,
+  "outputs": 4,
+  "neurons": 12,
+  "layers": 5,
+  "parameters": 36
+}

model.py

@@ -0,0 +1,54 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def and_gate(x, y, w, name):
+    inp = torch.tensor([float(x), float(y)])
+    return int((inp * w[f'{name}.weight']).sum() + w[f'{name}.bias'] >= 0)
+
+def half_adder_sum(x, y, w, prefix):
+    inp = torch.tensor([float(x), float(y)])
+    l1 = (inp @ w[f'{prefix}.xor.layer1.weight'].T + w[f'{prefix}.xor.layer1.bias'] >= 0).float()
+    return int((l1 @ w[f'{prefix}.xor.layer2.weight'].T + w[f'{prefix}.xor.layer2.bias'] >= 0).item())
+
+def half_adder_carry(x, y, w, prefix):
+    inp = torch.tensor([float(x), float(y)])
+    return int((inp * w[f'{prefix}.carry.weight']).sum() + w[f'{prefix}.carry.bias'] >= 0)
+
+def multiply_2x2(a0, a1, b0, b1, weights):
+    """2x2 binary multiplier.
+    Inputs: a = (a1, a0), b = (b1, b0) in MSB-first notation
+    Returns: (p0, p1, p2, p3) LSB-first, representing a × b
+    """
+    # Partial products
+    pp_a0b0 = and_gate(a0, b0, weights, 'a0b0')
+    pp_a1b0 = and_gate(a1, b0, weights, 'a1b0')
+    pp_a0b1 = and_gate(a0, b1, weights, 'a0b1')
+    pp_a1b1 = and_gate(a1, b1, weights, 'a1b1')
+
+    # p0 = a0 AND b0
+    p0 = pp_a0b0
+
+    # p1, c1 = half_add(a1b0, a0b1)
+    p1 = half_adder_sum(pp_a1b0, pp_a0b1, weights, 'ha_p1')
+    c1 = half_adder_carry(pp_a1b0, pp_a0b1, weights, 'ha_p1')
+
+    # p2, p3 = half_add(a1b1, c1)
+    p2 = half_adder_sum(pp_a1b1, c1, weights, 'ha_p2')
+    p3 = half_adder_carry(pp_a1b1, c1, weights, 'ha_p2')
+
+    return p0, p1, p2, p3
+
+if __name__ == '__main__':
+    w = load_model()
+    print('2x2 Binary Multiplier')
+    print('a × b tests:')
+    for a in range(4):
+        for b in range(4):
+            a0, a1 = a & 1, (a >> 1) & 1
+            b0, b1 = b & 1, (b >> 1) & 1
+            p0, p1, p2, p3 = multiply_2x2(a0, a1, b0, b1, w)
+            result = p0 + (p1 << 1) + (p2 << 2) + (p3 << 3)
+            print(f'{a} × {b} = {result}')

model.safetensors

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