CRC-16 CCITT at magnitude 53 using optimal XOR/XOR3

README.md

@@ -0,0 +1,145 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- error-detection
+- crc
+- optimized
+---
+
+# threshold-crc16-mag53
+
+CRC-16 CCITT single-step function using **magnitude-optimal XOR components**.
+
+## Optimization
+
+This circuit uses proven-optimal XOR decompositions instead of naive OR+NAND+AND:
+
+| Component | Naive Approach | Optimized | Savings |
+|-----------|---------------|-----------|---------|
+| XOR (2-input) | OR+NAND+AND (mag 10) | mag-7 symmetric | 30% |
+| XOR3 (3-input) | ge1/ge2/ge3 (mag 19) | mag-10 flat | 47% |
+
+**Total magnitude: 74 → 53 (28% reduction)**
+
+## XOR Component Choices
+
+### XOR (2-input) - Magnitude 7
+
+From the 6 proven-optimal solutions, we use the **symmetric opposites** family:
+
+```
+h1: [-1, +1], bias=0   (fires when b > a)
+h2: [+1, -1], bias=0   (fires when a > b)
+out: [-1, -1], bias=1  (NOR of hidden)
+```
+
+Selected for:
+- Zero biases in hidden layer (simpler accumulator)
+- Symmetric structure (clearer mathematical reasoning)
+- Proven optimal via exhaustive search (no mag-6 solutions exist)
+
+### XOR3 (3-input) - Magnitude 10
+
+From the 18 proven-optimal solutions, we use the **selector + full** pattern:
+
+```
+h1: [0, 0, -1], bias=0   (selector: fires when c=0)
+h2: [-1, +1, -1], bias=0 (full: fires when b > a+c)
+h3: [-1, -1, +1], bias=0 (full: fires when c > a+b)
+out: [+1, -1, -1], bias=0
+```
+
+Selected for:
+- All biases are zero
+- Selector neuron isolates the "unique" input in CRC context
+- Proven optimal via exhaustive search (387M configs, no mag-9 solutions)
+
+## Polynomial
+
+`0x1021` = x^16 + x^12 + x^5 + 1 (CRC-16-CCITT)
+
+## Function
+
+```
+feedback = C[15] XOR D
+
+C'[0]  = feedback           (tap at x^0)  ← XOR (mag 7)
+C'[1]  = C[0]
+C'[2]  = C[1]
+C'[3]  = C[2]
+C'[4]  = C[3]
+C'[5]  = C[4] XOR feedback  (tap at x^5)  ← XOR3 (mag 10)
+C'[6]  = C[5]
+...
+C'[11] = C[10]
+C'[12] = C[11] XOR feedback (tap at x^12) ← XOR3 (mag 10)
+C'[13] = C[12]
+C'[14] = C[13]
+C'[15] = C[14]
+```
+
+## Architecture
+
+| | |
+|---|---|
+| Inputs | 17 (C[0:15] + D) |
+| Outputs | 16 (C'[0:15]) |
+| Neurons | 24 |
+| Layers | 2 |
+| Parameters | 389 |
+| **Magnitude** | **53** |
+
+### Breakdown
+
+| Component | Neurons | Magnitude |
+|-----------|---------|-----------|
+| 13 pass-throughs | 13 | 26 |
+| C'[0] XOR | 3 | 7 |
+| C'[5] XOR3 | 4 | 10 |
+| C'[12] XOR3 | 4 | 10 |
+| **Total** | **24** | **53** |
+
+## Verification
+
+- Exhaustively tested against all 2^17 = 131,072 input combinations
+- XOR optimality proven via exhaustive search (magnitude 7, 6 solutions)
+- XOR3 optimality proven via exhaustive search (magnitude 10, 18 solutions)
+
+## Comparison to Naive Implementation
+
+| Version | Magnitude | Reduction |
+|---------|-----------|-----------|
+| threshold-crc16 (naive) | 74 | baseline |
+| **threshold-crc16-mag53** | **53** | **28%** |
+
+## Files
+
+```
+threshold-crc16-mag53/
+├── model.safetensors
+├── model.py
+├── create_safetensors.py
+├── config.json
+└── README.md
+```
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+from model import forward
+
+weights = load_file('model.safetensors')
+
+# Single step: 16-bit CRC state + 1 data bit → new 16-bit state
+inputs = [c0, c1, ..., c15, d]  # 17 binary values
+outputs = forward(inputs, weights)  # 16 binary values
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,17 @@
+{
+  "name": "threshold-crc16-mag53",
+  "description": "CRC-16 CCITT single-step using magnitude-optimal XOR components",
+  "inputs": 17,
+  "outputs": 16,
+  "neurons": 24,
+  "layers": 2,
+  "parameters": 389,
+  "magnitude": 53,
+  "polynomial": "0x1021",
+  "optimization": {
+    "xor_magnitude": 7,
+    "xor3_magnitude": 10,
+    "baseline_magnitude": 74,
+    "reduction_percent": 28
+  }
+}

create_safetensors.py

@@ -0,0 +1,215 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+def add_neuron(name, w_list, bias):
+    weights[f'{name}.weight'] = torch.tensor([w_list], dtype=torch.float32)
+    weights[f'{name}.bias'] = torch.tensor([bias], dtype=torch.float32)
+
+# CRC-16-CCITT (polynomial 0x1021: x^16 + x^12 + x^5 + 1)
+# Inputs: C[0], C[1], ..., C[15], D (indices 0-16), 17 total
+#
+# Using proven-optimal XOR (mag 7) and XOR3 (mag 10) structures:
+#   - XOR mag-7: symmetric family, h1=[-1,1] b=0, h2=[1,-1] b=0, out=[-1,-1] b=1
+#   - XOR3 mag-10: selector+full pattern, h1=sel, h2=full, h3=full, out weights
+#
+# Outputs:
+#   C'[0]  = C[15] XOR D          (2-input XOR, mag 7)
+#   C'[5]  = C[4] XOR C[15] XOR D (3-input XOR, mag 10)
+#   C'[12] = C[11] XOR C[15] XOR D (3-input XOR, mag 10)
+#   C'[i]  = C[i-1] for other positions (pass-through, mag 2 each)
+
+# ============================================================
+# PASS-THROUGH NEURONS (13 total, magnitude = 26)
+# C'[i] = C[i-1]: weight 1 on input, bias -1
+# ============================================================
+
+w = [0.0]*17; w[0] = 1.0
+add_neuron('c1', w, -1.0)   # C'[1] = C[0]
+
+w = [0.0]*17; w[1] = 1.0
+add_neuron('c2', w, -1.0)   # C'[2] = C[1]
+
+w = [0.0]*17; w[2] = 1.0
+add_neuron('c3', w, -1.0)   # C'[3] = C[2]
+
+w = [0.0]*17; w[3] = 1.0
+add_neuron('c4', w, -1.0)   # C'[4] = C[3]
+
+w = [0.0]*17; w[5] = 1.0
+add_neuron('c6', w, -1.0)   # C'[6] = C[5]
+
+w = [0.0]*17; w[6] = 1.0
+add_neuron('c7', w, -1.0)   # C'[7] = C[6]
+
+w = [0.0]*17; w[7] = 1.0
+add_neuron('c8', w, -1.0)   # C'[8] = C[7]
+
+w = [0.0]*17; w[8] = 1.0
+add_neuron('c9', w, -1.0)   # C'[9] = C[8]
+
+w = [0.0]*17; w[9] = 1.0
+add_neuron('c10', w, -1.0)  # C'[10] = C[9]
+
+w = [0.0]*17; w[10] = 1.0
+add_neuron('c11', w, -1.0)  # C'[11] = C[10]
+
+w = [0.0]*17; w[12] = 1.0
+add_neuron('c13', w, -1.0)  # C'[13] = C[12]
+
+w = [0.0]*17; w[13] = 1.0
+add_neuron('c14', w, -1.0)  # C'[14] = C[13]
+
+w = [0.0]*17; w[14] = 1.0
+add_neuron('c15', w, -1.0)  # C'[15] = C[14]
+
+# ============================================================
+# C'[0] = C[15] XOR D (2-input XOR, magnitude 7)
+# Using mag-7 symmetric family: h1=[-1,1], h2=[1,-1], out=[-1,-1] b=1
+# Inputs at indices 15 (C[15]) and 16 (D)
+# ============================================================
+
+w = [0.0]*17; w[15] = -1.0; w[16] = 1.0
+add_neuron('c0.h1', w, 0.0)  # fires when D > C[15]
+
+w = [0.0]*17; w[15] = 1.0; w[16] = -1.0
+add_neuron('c0.h2', w, 0.0)  # fires when C[15] > D
+
+add_neuron('c0.out', [-1.0, -1.0], 1.0)  # fires when exactly one hidden fires
+
+# ============================================================
+# C'[5] = C[4] XOR C[15] XOR D (3-input XOR, magnitude 10)
+# Using mag-10 selector pattern: sel on C[4], fulls on (C[4], C[15], D)
+# Inputs at indices 4 (C[4]), 15 (C[15]), 16 (D)
+# ============================================================
+
+w = [0.0]*17; w[4] = -1.0  # selector on C[4]
+add_neuron('c5.h1', w, 0.0)  # fires when C[4] = 0
+
+w = [0.0]*17; w[4] = -1.0; w[15] = 1.0; w[16] = -1.0
+add_neuron('c5.h2', w, 0.0)  # full pattern
+
+w = [0.0]*17; w[4] = -1.0; w[15] = -1.0; w[16] = 1.0
+add_neuron('c5.h3', w, 0.0)  # full pattern
+
+add_neuron('c5.out', [1.0, -1.0, -1.0], 0.0)
+
+# ============================================================
+# C'[12] = C[11] XOR C[15] XOR D (3-input XOR, magnitude 10)
+# Using mag-10 selector pattern: sel on C[11], fulls on (C[11], C[15], D)
+# Inputs at indices 11 (C[11]), 15 (C[15]), 16 (D)
+# ============================================================
+
+w = [0.0]*17; w[11] = -1.0  # selector on C[11]
+add_neuron('c12.h1', w, 0.0)  # fires when C[11] = 0
+
+w = [0.0]*17; w[11] = -1.0; w[15] = 1.0; w[16] = -1.0
+add_neuron('c12.h2', w, 0.0)  # full pattern
+
+w = [0.0]*17; w[11] = -1.0; w[15] = -1.0; w[16] = 1.0
+add_neuron('c12.h3', w, 0.0)  # full pattern
+
+add_neuron('c12.out', [1.0, -1.0, -1.0], 0.0)
+
+save_file(weights, 'model.safetensors')
+
+# ============================================================
+# Verification
+# ============================================================
+
+def crc16_step_ref(crc, data_bit):
+    feedback = ((crc >> 15) ^ data_bit) & 1
+    crc = (crc << 1) & 0xFFFF
+    if feedback:
+        crc ^= 0x1021
+    return crc
+
+def threshold_eval(inputs):
+    # Pass-throughs (layer 1, direct from inputs)
+    pass_throughs = {}
+    for name in ['c1', 'c2', 'c3', 'c4', 'c6', 'c7', 'c8', 'c9', 'c10', 'c11', 'c13', 'c14', 'c15']:
+        w = weights[f'{name}.weight'].flatten()
+        b = weights[f'{name}.bias'].item()
+        pass_throughs[name] = 1.0 if (inputs * w).sum() + b >= 0 else 0.0
+
+    # C'[0] XOR (layer 1 hidden)
+    c0_h1 = 1.0 if (inputs * weights['c0.h1.weight'].flatten()).sum() + weights['c0.h1.bias'].item() >= 0 else 0.0
+    c0_h2 = 1.0 if (inputs * weights['c0.h2.weight'].flatten()).sum() + weights['c0.h2.bias'].item() >= 0 else 0.0
+
+    # C'[0] XOR (layer 2 output)
+    h = torch.tensor([c0_h1, c0_h2])
+    c0_out = 1.0 if (h * weights['c0.out.weight'].flatten()).sum() + weights['c0.out.bias'].item() >= 0 else 0.0
+
+    # C'[5] XOR3 (layer 1 hidden)
+    c5_h1 = 1.0 if (inputs * weights['c5.h1.weight'].flatten()).sum() + weights['c5.h1.bias'].item() >= 0 else 0.0
+    c5_h2 = 1.0 if (inputs * weights['c5.h2.weight'].flatten()).sum() + weights['c5.h2.bias'].item() >= 0 else 0.0
+    c5_h3 = 1.0 if (inputs * weights['c5.h3.weight'].flatten()).sum() + weights['c5.h3.bias'].item() >= 0 else 0.0
+
+    # C'[5] XOR3 (layer 2 output)
+    h = torch.tensor([c5_h1, c5_h2, c5_h3])
+    c5_out = 1.0 if (h * weights['c5.out.weight'].flatten()).sum() + weights['c5.out.bias'].item() >= 0 else 0.0
+
+    # C'[12] XOR3 (layer 1 hidden)
+    c12_h1 = 1.0 if (inputs * weights['c12.h1.weight'].flatten()).sum() + weights['c12.h1.bias'].item() >= 0 else 0.0
+    c12_h2 = 1.0 if (inputs * weights['c12.h2.weight'].flatten()).sum() + weights['c12.h2.bias'].item() >= 0 else 0.0
+    c12_h3 = 1.0 if (inputs * weights['c12.h3.weight'].flatten()).sum() + weights['c12.h3.bias'].item() >= 0 else 0.0
+
+    # C'[12] XOR3 (layer 2 output)
+    h = torch.tensor([c12_h1, c12_h2, c12_h3])
+    c12_out = 1.0 if (h * weights['c12.out.weight'].flatten()).sum() + weights['c12.out.bias'].item() >= 0 else 0.0
+
+    # Assemble outputs
+    outputs = {
+        0: c0_out, 1: pass_throughs['c1'], 2: pass_throughs['c2'], 3: pass_throughs['c3'],
+        4: pass_throughs['c4'], 5: c5_out, 6: pass_throughs['c6'], 7: pass_throughs['c7'],
+        8: pass_throughs['c8'], 9: pass_throughs['c9'], 10: pass_throughs['c10'],
+        11: pass_throughs['c11'], 12: c12_out, 13: pass_throughs['c13'],
+        14: pass_throughs['c14'], 15: pass_throughs['c15']
+    }
+    return outputs
+
+print("Verifying CRC-16 mag53 threshold circuit...")
+errors = 0
+total = 0
+
+for crc in range(0, 65536, 257):
+    for d in [0, 1]:
+        inputs = torch.tensor([(crc >> i) & 1 for i in range(16)] + [d], dtype=torch.float32)
+        outputs = threshold_eval(inputs)
+        circuit_result = sum(int(outputs[i]) << i for i in range(16))
+        expected = crc16_step_ref(crc, d)
+        if circuit_result != expected:
+            errors += 1
+            if errors <= 5:
+                print(f"  FAIL: CRC=0x{crc:04X}, D={d} -> got 0x{circuit_result:04X}, expected 0x{expected:04X}")
+        total += 1
+
+if errors == 0:
+    print(f"All {total} sample tests passed!")
+else:
+    print(f"FAILED: {errors}/{total} errors")
+
+print("\nRunning exhaustive test (131,072 cases)...")
+errors = 0
+for crc in range(65536):
+    for d in [0, 1]:
+        inputs = torch.tensor([(crc >> i) & 1 for i in range(16)] + [d], dtype=torch.float32)
+        outputs = threshold_eval(inputs)
+        circuit_result = sum(int(outputs[i]) << i for i in range(16))
+        expected = crc16_step_ref(crc, d)
+        if circuit_result != expected:
+            errors += 1
+
+if errors == 0:
+    print("Exhaustive test PASSED!")
+else:
+    print(f"Exhaustive test FAILED: {errors}/131072 errors")
+
+mag = sum(t.abs().sum().item() for t in weights.values())
+params = sum(t.numel() for t in weights.values())
+neurons = len([k for k in weights if '.weight' in k])
+print(f"\nCircuit stats:")
+print(f"  Neurons: {neurons}")
+print(f"  Parameters: {params}")
+print(f"  Magnitude: {mag:.0f}")