Upload folder using huggingface_hub

README.md

@@ -0,0 +1,147 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- arithmetic
+---
+
+# threshold-ripplecarry4bit
+
+Adds two 4-bit numbers with carry-in. Four cascaded full adders in the classic ripple-carry architecture.
+
+## Circuit
+
+```
+   a0 b0 cin        a1 b1          a2 b2          a3 b3
+    │  │  │          │  │           │  │           │  │
+    └──┼──┘          └──┼──┘        └──┼──┘        └──┼──┘
+       ▼                ▼              ▼              ▼
+   ┌───────┐        ┌───────┐      ┌───────┐      ┌───────┐
+   │  FA0  │───c0───│  FA1  │──c1──│  FA2  │──c2──│  FA3  │───cout
+   └───────┘        └───────┘      └───────┘      └───────┘
+       │                │              │              │
+       ▼                ▼              ▼              ▼
+      s0               s1             s2             s3
+
+
+   Input:  (a3 a2 a1 a0) + (b3 b2 b1 b0) + cin
+   Output: (cout s3 s2 s1 s0)
+```
+
+The carry ripples through each full adder sequentially, hence "ripple-carry."
+
+## Full Adder Structure (each FA)
+
+```
+        a       b
+        │       │
+        └───┬───┘
+            ▼
+       ┌─────────┐
+       │   HA1   │  Half adder 1
+       └─────────┘
+        │       │
+       s1       c1
+        │        \
+        │   cin   \
+        └──┬──┘    \
+           ▼        \
+      ┌─────────┐    \
+      │   HA2   │     │
+      └─────────┘     │
+       │       │      │
+      sum      c2     │
+               │      │
+               └──┬───┘
+                  ▼
+              ┌──────┐
+              │  OR  │
+              └──────┘
+                  │
+                  ▼
+                cout
+```
+
+## Example
+
+```
+    1111  (15)
+  + 0001  ( 1)
+  ──────
+   10000  (16)
+```
+
+15 + 1 = 16, which overflows 4 bits. The result is s=[0,0,0,0] with cout=1.
+
+## Architecture
+
+| Component | Per FA | Total (4 FAs) |
+|-----------|--------|---------------|
+| Neurons | 9 | 36 |
+| Parameters | 27 | 108 |
+| Layers | 4 | 16 |
+
+## Inputs/Outputs
+
+| Name | Bits | Description |
+|------|------|-------------|
+| a | a3..a0 | First 4-bit number (LSB = a0) |
+| b | b3..b0 | Second 4-bit number (LSB = b0) |
+| cin | 1 | Carry in |
+| s | s3..s0 | 4-bit sum (LSB = s0) |
+| cout | 1 | Carry out |
+
+## Critical Path
+
+The worst-case delay is when a carry must propagate through all 4 full adders:
+
+```
+cin → FA0.cout → FA1.cout → FA2.cout → FA3.cout
+```
+
+This is 4 × 4 = 16 layers deep. Carry-lookahead would reduce this but requires more complex circuitry.
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+
+w = load_file('model.safetensors')
+
+def ripple_carry_4bit(a, b, cin):
+    """a, b: 4-bit lists [a0,a1,a2,a3] (LSB first)"""
+    # See model.py for full implementation
+    pass
+
+# Example: 7 + 5 = 12
+a = [1, 1, 1, 0]  # 7 in LSB-first
+b = [1, 0, 1, 0]  # 5 in LSB-first
+sums, cout = ripple_carry_4bit(a, b, 0)
+# sums = [0, 0, 1, 1], cout = 0 → 12
+```
+
+## Scaling
+
+| Bits | Full Adders | Neurons | Parameters | Max Depth |
+|------|-------------|---------|------------|-----------|
+| 2 | 2 | 18 | 54 | 8 |
+| 4 | 4 | 36 | 108 | 16 |
+| 8 | 8 | 72 | 216 | 32 |
+| n | n | 9n | 27n | 4n |
+
+## Files
+
+```
+threshold-ripplecarry4bit/
+├── model.safetensors
+├── model.py
+├── config.json
+└── README.md
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-ripplecarry4bit",
+  "description": "4-bit ripple carry adder as threshold circuit",
+  "inputs": 9,
+  "outputs": 5,
+  "neurons": 36,
+  "layers": 16,
+  "parameters": 108
+}

model.py

@@ -0,0 +1,63 @@
+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)])
+
+    # HA1: a + 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)
+
+    # HA2: s1 + cin
+    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)
+
+    # Carry OR
+    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_4bit(a, b, cin, weights):
+    """4-bit ripple carry adder.
+    a, b: lists of 4 bits each (LSB first)
+    cin: carry in
+    Returns: (sums, cout) where sums is 4-bit list (LSB first)
+    """
+    carries = [cin]
+    sums = []
+    for i in range(4):
+        s, c = full_adder(a[i], b[i], carries[i], weights, f'fa{i}')
+        sums.append(s)
+        carries.append(c)
+    return sums, carries[4]
+
+if __name__ == '__main__':
+    w = load_model()
+    print('4-bit Ripple Carry Adder')
+    print('Testing all combinations would be 2^9 = 512 cases.')
+    print('Sample tests:')
+    tests = [
+        ([0,0,0,0], [0,0,0,0], 0, 0),
+        ([1,0,0,0], [1,0,0,0], 0, 2),
+        ([1,1,1,1], [1,0,0,0], 0, 16),
+        ([1,1,1,1], [1,1,1,1], 0, 30),
+        ([0,1,0,1], [0,1,0,1], 0, 20),
+        ([1,1,0,0], [1,1,0,0], 0, 6),
+    ]
+    for a, b, cin, expected in tests:
+        sums, cout = ripple_carry_4bit(a, b, cin, w)
+        result = sum(bit << i for i, bit in enumerate(sums)) + (cout << 4)
+        a_val = sum(bit << i for i, bit in enumerate(a))
+        b_val = sum(bit << i for i, bit in enumerate(b))
+        status = "OK" if result == expected else "FAIL"
+        print(f'{a_val:2d} + {b_val:2d} + {cin} = {result:2d} {status}')

model.safetensors

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