Upload folder using huggingface_hub

README.md

@@ -0,0 +1,180 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- error-correction
+- hamming-code
+---
+
+# threshold-hamming74encoder
+
+Hamming(7,4) encoder. Transforms 4 data bits into a 7-bit codeword with single-error correction capability.
+
+## Circuit Overview
+
+```
+     d1  d2  d3  d4
+      │   │   │   │
+      ├───┼───┼───┤
+      │   │   │   │
+      │   │   │   └────────────────────────────► c7 = d4
+      │   │   └───────────────────────► c6 = d3
+      │   └──────────────────► c5 = d2
+      └─────────────► c3 = d1
+      │   │   │   │
+      ▼   ▼   │   ▼
+    ┌───────────────┐
+    │ d1 XOR d2 XOR │──────► c1 = p1
+    │      d4       │
+    └───────────────┘
+      │       │   │
+      ▼       ▼   ▼
+    ┌───────────────┐
+    │ d1 XOR d3 XOR │──────► c2 = p2
+    │      d4       │
+    └───────────────┘
+          │   │   │
+          ▼   ▼   ▼
+        ┌───────────────┐
+        │ d2 XOR d3 XOR │──► c4 = p3
+        │      d4       │
+        └───────────────┘
+```
+
+## The Hamming(7,4) Code
+
+Richard Hamming invented this code in 1950. It encodes 4 data bits into 7 bits such that any single-bit error can be detected and corrected.
+
+**Codeword structure:**
+
+| Position | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+|----------|---|---|---|---|---|---|---|
+| Bit | p1 | p2 | d1 | p3 | d2 | d3 | d4 |
+| Type | parity | parity | data | parity | data | data | data |
+
+**Parity equations:**
+- p1 = d1 ⊕ d2 ⊕ d4 (covers positions 1,3,5,7)
+- p2 = d1 ⊕ d3 ⊕ d4 (covers positions 2,3,6,7)
+- p3 = d2 ⊕ d3 ⊕ d4 (covers positions 4,5,6,7)
+
+## 3-Way XOR Implementation
+
+Each parity bit requires a 3-input XOR. In threshold logic:
+
+```
+XOR(a,b,c) = XOR(XOR(a,b), c)
+
+      a   b
+      │   │
+      └─┬─┘
+        ▼
+    ┌───────┐
+    │ XOR   │  (2 layers)
+    └───────┘
+        │
+        │   c
+        └─┬─┘
+          ▼
+      ┌───────┐
+      │ XOR   │  (2 more layers)
+      └───────┘
+          │
+          ▼
+     XOR(a,b,c)
+```
+
+Total depth: 4 layers per parity. All three parities compute in parallel.
+
+## Code Properties
+
+| Property | Value |
+|----------|-------|
+| Data bits (k) | 4 |
+| Codeword bits (n) | 7 |
+| Parity bits (n-k) | 3 |
+| Minimum distance | 3 |
+| Error correction | 1 bit |
+| Error detection | 2 bits |
+
+## Example Encoding
+
+```
+Data: 1011
+
+p1 = 1 ⊕ 0 ⊕ 1 = 0
+p2 = 1 ⊕ 1 ⊕ 1 = 1
+p3 = 0 ⊕ 1 ⊕ 1 = 0
+
+Codeword: 0110011
+          ↑↑ ↑
+          p1p2p3
+```
+
+## Architecture
+
+| Component | Neurons | Parameters |
+|-----------|---------|------------|
+| p1 (3-way XOR) | 6 | 22 |
+| p2 (3-way XOR) | 6 | 22 |
+| p3 (3-way XOR) | 6 | 22 |
+| d1-d4 pass-through | 4 | 20 |
+| **Total** | **22** | **86** |
+
+**Layers: 4** (two cascaded XOR stages)
+
+## All 16 Codewords
+
+| Data | Codeword | HW |
+|------|----------|-----|
+| 0000 | 0000000 | 0 |
+| 1000 | 1110000 | 3 |
+| 0100 | 1001100 | 3 |
+| 1100 | 0111100 | 4 |
+| 0010 | 0101010 | 3 |
+| 1010 | 1011010 | 4 |
+| 0110 | 1100110 | 4 |
+| 1110 | 0010110 | 3 |
+| 0001 | 1101001 | 4 |
+| 1001 | 0011001 | 3 |
+| 0101 | 0100101 | 3 |
+| 1101 | 1010101 | 4 |
+| 0011 | 1000011 | 3 |
+| 1011 | 0110011 | 4 |
+| 0111 | 0001111 | 4 |
+| 1111 | 1111111 | 7 |
+
+Note: Minimum Hamming distance between any two codewords is 3.
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+
+w = load_file('model.safetensors')
+
+def hamming74_encode(d1, d2, d3, d4):
+    """Encode 4 data bits to 7-bit Hamming codeword"""
+    # See model.py for full implementation
+    pass
+
+# Encode data word 1011
+codeword = hamming74_encode(1, 0, 1, 1)
+# Returns [0, 1, 1, 0, 0, 1, 1]
+```
+
+## Files
+
+```
+threshold-hamming74encoder/
+├── model.safetensors
+├── model.py
+├── config.json
+└── README.md
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-hamming74encoder",
+  "description": "Hamming(7,4) encoder as threshold circuit",
+  "inputs": 4,
+  "outputs": 7,
+  "neurons": 22,
+  "layers": 4,
+  "parameters": 86
+}

model.py

@@ -0,0 +1,80 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def xor2_from_weights(a, b, w, or_w, or_b, nand_w, nand_b, and_w, and_b):
+    """Compute XOR(a,b) using threshold gates"""
+    inp = torch.tensor([float(a), float(b)])
+    or_out = float((inp * or_w).sum() + or_b >= 0)
+    nand_out = float((inp * nand_w).sum() + nand_b >= 0)
+    l1 = torch.tensor([or_out, nand_out])
+    return int((l1 * and_w).sum() + and_b >= 0)
+
+def hamming74_encode(d1, d2, d3, d4, w):
+    """Hamming(7,4) encoder: 4 data bits -> 7 coded bits"""
+    inp = torch.tensor([float(d1), float(d2), float(d3), float(d4)])
+
+    # p1 = d1 XOR d2 XOR d4
+    or_out = float((inp * w['p1.xor12.layer1.or.weight']).sum() + w['p1.xor12.layer1.or.bias'] >= 0)
+    nand_out = float((inp * w['p1.xor12.layer1.nand.weight']).sum() + w['p1.xor12.layer1.nand.bias'] >= 0)
+    xor12 = int((torch.tensor([or_out, nand_out]) * w['p1.xor12.layer2.weight']).sum() + w['p1.xor12.layer2.bias'] >= 0)
+
+    inp2 = torch.tensor([float(xor12), float(d4)])
+    or_out = float((inp2 * w['p1.xor_final.layer1.or.weight']).sum() + w['p1.xor_final.layer1.or.bias'] >= 0)
+    nand_out = float((inp2 * w['p1.xor_final.layer1.nand.weight']).sum() + w['p1.xor_final.layer1.nand.bias'] >= 0)
+    p1 = int((torch.tensor([or_out, nand_out]) * w['p1.xor_final.layer2.weight']).sum() + w['p1.xor_final.layer2.bias'] >= 0)
+
+    # p2 = d1 XOR d3 XOR d4
+    or_out = float((inp * w['p2.xor13.layer1.or.weight']).sum() + w['p2.xor13.layer1.or.bias'] >= 0)
+    nand_out = float((inp * w['p2.xor13.layer1.nand.weight']).sum() + w['p2.xor13.layer1.nand.bias'] >= 0)
+    xor13 = int((torch.tensor([or_out, nand_out]) * w['p2.xor13.layer2.weight']).sum() + w['p2.xor13.layer2.bias'] >= 0)
+
+    inp2 = torch.tensor([float(xor13), float(d4)])
+    or_out = float((inp2 * w['p2.xor_final.layer1.or.weight']).sum() + w['p2.xor_final.layer1.or.bias'] >= 0)
+    nand_out = float((inp2 * w['p2.xor_final.layer1.nand.weight']).sum() + w['p2.xor_final.layer1.nand.bias'] >= 0)
+    p2 = int((torch.tensor([or_out, nand_out]) * w['p2.xor_final.layer2.weight']).sum() + w['p2.xor_final.layer2.bias'] >= 0)
+
+    # p3 = d2 XOR d3 XOR d4
+    or_out = float((inp * w['p3.xor23.layer1.or.weight']).sum() + w['p3.xor23.layer1.or.bias'] >= 0)
+    nand_out = float((inp * w['p3.xor23.layer1.nand.weight']).sum() + w['p3.xor23.layer1.nand.bias'] >= 0)
+    xor23 = int((torch.tensor([or_out, nand_out]) * w['p3.xor23.layer2.weight']).sum() + w['p3.xor23.layer2.bias'] >= 0)
+
+    inp2 = torch.tensor([float(xor23), float(d4)])
+    or_out = float((inp2 * w['p3.xor_final.layer1.or.weight']).sum() + w['p3.xor_final.layer1.or.bias'] >= 0)
+    nand_out = float((inp2 * w['p3.xor_final.layer1.nand.weight']).sum() + w['p3.xor_final.layer1.nand.bias'] >= 0)
+    p3 = int((torch.tensor([or_out, nand_out]) * w['p3.xor_final.layer2.weight']).sum() + w['p3.xor_final.layer2.bias'] >= 0)
+
+    # Data pass-through
+    c3 = int((inp * w['d1.weight']).sum() + w['d1.bias'] >= 0)
+    c5 = int((inp * w['d2.weight']).sum() + w['d2.bias'] >= 0)
+    c6 = int((inp * w['d3.weight']).sum() + w['d3.bias'] >= 0)
+    c7 = int((inp * w['d4.weight']).sum() + w['d4.bias'] >= 0)
+
+    # Output: c1=p1, c2=p2, c3=d1, c4=p3, c5=d2, c6=d3, c7=d4
+    return [p1, p2, c3, p3, c5, c6, c7]
+
+if __name__ == '__main__':
+    w = load_model()
+    print('Hamming(7,4) Encoder')
+    print('Input (d1d2d3d4) -> Output (c1c2c3c4c5c6c7)')
+
+    def ref_encode(d1, d2, d3, d4):
+        p1 = d1 ^ d2 ^ d4
+        p2 = d1 ^ d3 ^ d4
+        p3 = d2 ^ d3 ^ d4
+        return [p1, p2, d1, p3, d2, d3, d4]
+
+    errors = 0
+    for d in range(16):
+        d1, d2, d3, d4 = (d>>0)&1, (d>>1)&1, (d>>2)&1, (d>>3)&1
+        result = hamming74_encode(d1, d2, d3, d4, w)
+        expected = ref_encode(d1, d2, d3, d4)
+        status = 'OK' if result == expected else 'FAIL'
+        if result != expected:
+            errors += 1
+        r_str = ''.join(map(str, result))
+        print(f'{d1}{d2}{d3}{d4} -> {r_str} {status}')
+
+    print(f'\n{16-errors}/16 correct')

model.safetensors

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