threshold-ripplecarry8bit

Adds two 8-bit numbers with carry-in. Eight cascaded full adders in ripple-carry architecture.

Circuit

 a0 b0      a1 b1      a2 b2      a3 b3      a4 b4      a5 b5      a6 b6      a7 b7
  │ │        │ │        │ │        │ │        │ │        │ │        │ │        │ │
  └┬┘        └┬┘        └┬┘        └┬┘        └┬┘        └┬┘        └┬┘        └┬┘
   ▼          ▼          ▼          ▼          ▼          ▼          ▼          ▼
┌────┐ c0 ┌────┐ c1 ┌────┐ c2 ┌────┐ c3 ┌────┐ c4 ┌────┐ c5 ┌────┐ c6 ┌────┐
│FA0 │────│FA1 │────│FA2 │────│FA3 │────│FA4 │────│FA5 │────│FA6 │────│FA7 │──cout
└────┘    └────┘    └────┘    └────┘    └────┘    └────┘    └────┘    └────┘
   │         │         │         │         │         │         │         │
   ▼         ▼         ▼         ▼         ▼         ▼         ▼         ▼
  s0        s1        s2        s3        s4        s5        s6        s7

cin─┘


   Input:  (a7..a0) + (b7..b0) + cin
   Output: (cout s7..s0)

Example

    11111111  (255)
  + 00000001  (  1)
  ──────────
   100000000  (256)

255 + 1 = 256. The sum bits are all 0, cout = 1.

Architecture

Component	Per FA	Total (8 FAs)
Neurons	9	72
Parameters	27	216
Layers	4	32

Inputs/Outputs

Name	Bits	Description
a	a7..a0	First 8-bit number (LSB = a0)
b	b7..b0	Second 8-bit number (LSB = b0)
cin	1	Carry in
s	s7..s0	8-bit sum (LSB = s0)
cout	1	Carry out

Critical Path

Worst-case: carry propagates through all 8 full adders.

cin → FA0 → FA1 → FA2 → FA3 → FA4 → FA5 → FA6 → FA7 → cout

This is 8 × 4 = 32 layers deep. For a byte-wide ALU, this latency is acceptable. For wider words, carry-lookahead or prefix adders would be preferred.

Range

• Input: 0-255 + 0-255 + 0-1 = 0-511
• Output: 9 bits (8-bit sum + 1-bit carry)

Usage

from safetensors.torch import load_file

w = load_file('model.safetensors')

def ripple_carry_8bit(a, b, cin):
    """a, b: 8-bit lists [a0..a7] (LSB first)"""
    # See model.py for full implementation
    pass

# Example: 200 + 100 = 300 (overflow to 9 bits)
a = [(200 >> i) & 1 for i in range(8)]  # 200 in LSB-first
b = [(100 >> i) & 1 for i in range(8)]  # 100 in LSB-first
sums, cout = ripple_carry_8bit(a, b, 0)
result = sum(bit << i for i, bit in enumerate(sums)) + (cout << 8)
# result = 300

Scaling

Bits	Full Adders	Neurons	Parameters	Max Depth
2	2	18	54	8
4	4	36	108	16
8	8	72	216	32
16	16	144	432	64
n	n	9n	27n	4n

Files

threshold-ripplecarry8bit/
├── model.safetensors
├── model.py
├── config.json
└── README.md

License

MIT