Upload folder using huggingface_hub

README.md

@@ -0,0 +1,122 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- arithmetic
+---
+
+# 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
+
+```python
+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

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-ripplecarry8bit",
+  "description": "8-bit ripple carry adder as threshold circuit",
+  "inputs": 17,
+  "outputs": 9,
+  "neurons": 72,
+  "layers": 32,
+  "parameters": 216
+}

model.py

@@ -0,0 +1,47 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def full_adder(a, b, cin, w, prefix):
+    """Single full adder: a + b + cin = (sum, cout)"""
+    inp = torch.tensor([float(a), float(b)])
+    or_out = (inp * w[f'{prefix}.ha1.sum.layer1.or.weight']).sum() + w[f'{prefix}.ha1.sum.layer1.or.bias'] >= 0
+    nand_out = (inp * w[f'{prefix}.ha1.sum.layer1.nand.weight']).sum() + w[f'{prefix}.ha1.sum.layer1.nand.bias'] >= 0
+    l1 = torch.tensor([float(or_out), float(nand_out)])
+    s1 = float((l1 * w[f'{prefix}.ha1.sum.layer2.weight']).sum() + w[f'{prefix}.ha1.sum.layer2.bias'] >= 0)
+    c1 = float((inp * w[f'{prefix}.ha1.carry.weight']).sum() + w[f'{prefix}.ha1.carry.bias'] >= 0)
+    inp2 = torch.tensor([s1, float(cin)])
+    or_out2 = (inp2 * w[f'{prefix}.ha2.sum.layer1.or.weight']).sum() + w[f'{prefix}.ha2.sum.layer1.or.bias'] >= 0
+    nand_out2 = (inp2 * w[f'{prefix}.ha2.sum.layer1.nand.weight']).sum() + w[f'{prefix}.ha2.sum.layer1.nand.bias'] >= 0
+    l2 = torch.tensor([float(or_out2), float(nand_out2)])
+    s = int((l2 * w[f'{prefix}.ha2.sum.layer2.weight']).sum() + w[f'{prefix}.ha2.sum.layer2.bias'] >= 0)
+    c2 = float((inp2 * w[f'{prefix}.ha2.carry.weight']).sum() + w[f'{prefix}.ha2.carry.bias'] >= 0)
+    cout = int((torch.tensor([c1, c2]) * w[f'{prefix}.carry_or.weight']).sum() + w[f'{prefix}.carry_or.bias'] >= 0)
+    return s, cout
+
+def ripple_carry_8bit(a, b, cin, weights):
+    """8-bit ripple carry adder.
+    a, b: lists of 8 bits each (LSB first)
+    cin: carry in
+    Returns: (sums, cout) where sums is 8-bit list (LSB first)
+    """
+    carries = [cin]
+    sums = []
+    for i in range(8):
+        s, c = full_adder(a[i], b[i], carries[i], weights, f'fa{i}')
+        sums.append(s)
+        carries.append(c)
+    return sums, carries[8]
+
+if __name__ == '__main__':
+    w = load_model()
+    print('8-bit Ripple Carry Adder')
+    tests = [(255, 1), (127, 128), (100, 55), (200, 200), (0, 0), (128, 128)]
+    for a_val, b_val in tests:
+        a = [(a_val >> i) & 1 for i in range(8)]
+        b = [(b_val >> i) & 1 for i in range(8)]
+        sums, cout = ripple_carry_8bit(a, b, 0, w)
+        result = sum(bit << i for i, bit in enumerate(sums)) + (cout << 8)
+        print(f'{a_val:3d} + {b_val:3d} = {result:3d}')

model.safetensors

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