4-bit Gray to binary converter, magnitude 33

README.md

@@ -0,0 +1,75 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+---
+
+# threshold-gray2binary
+
+4-bit Gray code to binary converter.
+
+## Function
+
+gray2binary(G3, G2, G1, G0) -> (B3, B2, B1, B0)
+
+Conversion formulas:
+- B3 = G3
+- B2 = G3 XOR G2
+- B1 = G3 XOR G2 XOR G1
+- B0 = G3 XOR G2 XOR G1 XOR G0
+
+## Example Conversions
+
+| Gray | Binary |
+|------|--------|
+| 0000 | 0000 (0) |
+| 0001 | 0001 (1) |
+| 0011 | 0010 (2) |
+| 0010 | 0011 (3) |
+| 0110 | 0100 (4) |
+| 0111 | 0101 (5) |
+| 0101 | 0110 (6) |
+| 0100 | 0111 (7) |
+
+## Architecture
+
+Cascade XOR structure with shared intermediate results:
+
+```
+G3 ──────────────────────────────────────────► B3
+G3,G2 ─► [XOR] ─► X1 ────────────────────────► B2
+              X1,G1 ─► [XOR] ─► X2 ──────────► B1
+                            X2,G0 ─► [XOR] ──► B0
+```
+
+Each XOR uses 3 neurons (OR, NAND, AND) with mag-7 weights.
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 4 |
+| Outputs | 4 |
+| Neurons | 10 |
+| Layers | 6 |
+| Parameters | 46 |
+| Magnitude | 33 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+# Convert gray code 0110 (which is binary 4)
+# Full implementation in model.py
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-gray2binary",
+  "description": "4-bit Gray code to binary converter",
+  "inputs": 4,
+  "outputs": 4,
+  "neurons": 10,
+  "layers": 6,
+  "parameters": 46
+}

create_safetensors.py

@@ -0,0 +1,98 @@
+import torch
+from safetensors.torch import save_file
+
+# Gray to Binary: B[i] = XOR(G[n-1], G[n-2], ..., G[i])
+# B3 = G3
+# B2 = G3 XOR G2
+# B1 = G3 XOR G2 XOR G1
+# B0 = G3 XOR G2 XOR G1 XOR G0
+#
+# Using cascade XOR: XOR(a,b) = AND(OR(a,b), NAND(a,b))
+# With sharing: X1 = XOR(G3,G2), X2 = XOR(X1,G1), X3 = XOR(X2,G0)
+# B3=G3, B2=X1, B1=X2, B0=X3
+
+weights = {}
+
+# Inputs: G3, G2, G1, G0
+
+# === B3 = G3 (identity) ===
+weights['b3.weight'] = torch.tensor([[2.0, 0.0, 0.0, 0.0]], dtype=torch.float32)
+weights['b3.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# === X1 = XOR(G3, G2) → B2 ===
+# Layer 1: OR and NAND from inputs
+weights['x1_or.weight'] = torch.tensor([[1.0, 1.0, 0.0, 0.0]], dtype=torch.float32)
+weights['x1_or.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+weights['x1_nand.weight'] = torch.tensor([[-1.0, -1.0, 0.0, 0.0]], dtype=torch.float32)
+weights['x1_nand.bias'] = torch.tensor([1.0], dtype=torch.float32)
+# Layer 2: AND(or, nand) → X1 = B2
+weights['b2.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['b2.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# === X2 = XOR(X1, G1) → B1 ===
+# Need to feed X1 (from layer 2) and G1 (from input)
+# Layer 3: OR(X1, G1), NAND(X1, G1)
+# X1 is neuron output, G1 is input[2]
+weights['x2_or.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)  # [X1, G1]
+weights['x2_or.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+weights['x2_nand.weight'] = torch.tensor([[-1.0, -1.0]], dtype=torch.float32)
+weights['x2_nand.bias'] = torch.tensor([1.0], dtype=torch.float32)
+# Layer 4: AND → X2 = B1
+weights['b1.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['b1.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# === X3 = XOR(X2, G0) → B0 ===
+# Layer 5: OR(X2, G0), NAND(X2, G0)
+weights['x3_or.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['x3_or.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+weights['x3_nand.weight'] = torch.tensor([[-1.0, -1.0]], dtype=torch.float32)
+weights['x3_nand.bias'] = torch.tensor([1.0], dtype=torch.float32)
+# Layer 6: AND → X3 = B0
+weights['b0.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['b0.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+save_file(weights, 'model.safetensors')
+
+def gray2binary(g3, g2, g1, g0):
+    # B3 = G3
+    b3 = int(g3 * 2 - 1 >= 0)
+
+    # X1 = XOR(G3, G2)
+    x1_or = int(g3 + g2 - 1 >= 0)
+    x1_nand = int(-g3 - g2 + 1 >= 0)
+    x1 = int(x1_or + x1_nand - 2 >= 0)
+    b2 = x1
+
+    # X2 = XOR(X1, G1)
+    x2_or = int(x1 + g1 - 1 >= 0)
+    x2_nand = int(-x1 - g1 + 1 >= 0)
+    x2 = int(x2_or + x2_nand - 2 >= 0)
+    b1 = x2
+
+    # X3 = XOR(X2, G0)
+    x3_or = int(x2 + g0 - 1 >= 0)
+    x3_nand = int(-x2 - g0 + 1 >= 0)
+    x3 = int(x3_or + x3_nand - 2 >= 0)
+    b0 = x3
+
+    return b3, b2, b1, b0
+
+print("Verifying gray2binary...")
+errors = 0
+for i in range(16):
+    # Convert i to gray code
+    gray = i ^ (i >> 1)
+    g3, g2, g1, g0 = (gray >> 3) & 1, (gray >> 2) & 1, (gray >> 1) & 1, gray & 1
+
+    b3, b2, b1, b0 = gray2binary(g3, g2, g1, g0)
+    result = b3 * 8 + b2 * 4 + b1 * 2 + b0
+
+    if result != i:
+        errors += 1
+        print(f"ERROR: gray {g3}{g2}{g1}{g0} (={gray}) -> {b3}{b2}{b1}{b0} (={result}), expected {i}")
+
+if errors == 0:
+    print("All 16 test cases passed!")
+
+mag = sum(t.abs().sum().item() for t in weights.values())
+print(f"Magnitude: {mag:.0f}")

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 gray2binary(g3, g2, g1, g0, weights):
+    """Convert 4-bit Gray code to binary."""
+    inp = torch.tensor([float(g3), float(g2), float(g1), float(g0)])
+
+    # B3 = G3
+    b3 = int((inp @ weights['b3.weight'].T + weights['b3.bias'] >= 0).item())
+
+    # X1 = XOR(G3, G2)
+    x1_or = int((inp @ weights['x1_or.weight'].T + weights['x1_or.bias'] >= 0).item())
+    x1_nand = int((inp @ weights['x1_nand.weight'].T + weights['x1_nand.bias'] >= 0).item())
+    x1_vec = torch.tensor([float(x1_or), float(x1_nand)])
+    b2 = int((x1_vec @ weights['b2.weight'].T + weights['b2.bias'] >= 0).item())
+    x1 = b2
+
+    # X2 = XOR(X1, G1)
+    x2_inp = torch.tensor([float(x1), float(g1)])
+    x2_or = int((x2_inp @ weights['x2_or.weight'].T + weights['x2_or.bias'] >= 0).item())
+    x2_nand = int((x2_inp @ weights['x2_nand.weight'].T + weights['x2_nand.bias'] >= 0).item())
+    x2_vec = torch.tensor([float(x2_or), float(x2_nand)])
+    b1 = int((x2_vec @ weights['b1.weight'].T + weights['b1.bias'] >= 0).item())
+    x2 = b1
+
+    # X3 = XOR(X2, G0)
+    x3_inp = torch.tensor([float(x2), float(g0)])
+    x3_or = int((x3_inp @ weights['x3_or.weight'].T + weights['x3_or.bias'] >= 0).item())
+    x3_nand = int((x3_inp @ weights['x3_nand.weight'].T + weights['x3_nand.bias'] >= 0).item())
+    x3_vec = torch.tensor([float(x3_or), float(x3_nand)])
+    b0 = int((x3_vec @ weights['b0.weight'].T + weights['b0.bias'] >= 0).item())
+
+    return b3, b2, b1, b0
+
+if __name__ == '__main__':
+    w = load_model()
+    print('Gray to Binary conversion:')
+    print('Binary -> Gray -> Binary')
+    for i in range(16):
+        gray = i ^ (i >> 1)
+        g3, g2, g1, g0 = (gray >> 3) & 1, (gray >> 2) & 1, (gray >> 1) & 1, gray & 1
+        b3, b2, b1, b0 = gray2binary(g3, g2, g1, g0, w)
+        result = b3 * 8 + b2 * 4 + b1 * 2 + b0
+        print(f'  {i:2d} -> {g3}{g2}{g1}{g0} -> {b3}{b2}{b1}{b0} = {result:2d}')