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

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