Upload folder using huggingface_hub

README.md

@@ -0,0 +1,67 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+---
+
+# threshold-xor4
+
+4-input XOR gate. Cascade of three standard XOR circuits (OR + NAND + AND).
+
+## Architecture
+
+```
+a  b       c       d
+│  │       │       │
+└──┴──┐    │       │
+      ▼    │       │
+   ┌─────┐ │       │
+   │ XOR │ │       │
+   └──┬──┘ │       │
+      └──┬─┘       │
+         ▼         │
+      ┌─────┐      │
+      │ XOR │      │
+      └──┬──┘      │
+         └────┬────┘
+              ▼
+           ┌─────┐
+           │ XOR │
+           └──┬──┘
+              ▼
+        XOR4(a,b,c,d)
+```
+
+Each XOR uses the standard OR + NAND + AND structure:
+- OR: w=[1,1], b=-1 (magnitude 3)
+- NAND: w=[-1,-1], b=1 (magnitude 3)
+- AND: w=[1,1], b=-2 (magnitude 4)
+
+## Parameters
+
+| | |
+|---|---|
+| Neurons | 9 |
+| Layers | 6 |
+| Parameters | 27 |
+| Magnitude | 30 |
+
+## Optimized Version
+
+See `threshold-xor4-mag21` for a 30% magnitude reduction using optimized XOR blocks.
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+
+w = load_file('model.safetensors')
+# See model.py for implementation
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,21 @@
+{
+  "model_type": "threshold_network",
+  "task": "xor4_gate",
+  "architecture": "4 -> 2 -> 1 -> 2 -> 1 -> 2 -> 1",
+  "input_size": 4,
+  "output_size": 1,
+  "num_neurons": 9,
+  "num_layers": 6,
+  "num_parameters": 27,
+  "magnitude": 30,
+  "activation": "heaviside",
+  "weight_constraints": "integer",
+  "verification": {
+    "method": "exhaustive",
+    "inputs_tested": 16
+  },
+  "accuracy": {
+    "all_inputs": "16/16",
+    "percentage": 100.0
+  }
+}

create_safetensors.py

@@ -0,0 +1,21 @@
+import torch
+from safetensors.torch import save_file
+
+def xor_block(prefix):
+    return {
+        f'{prefix}.layer1.or.weight': torch.tensor([1.0, 1.0]),
+        f'{prefix}.layer1.or.bias': torch.tensor([-1.0]),
+        f'{prefix}.layer1.nand.weight': torch.tensor([-1.0, -1.0]),
+        f'{prefix}.layer1.nand.bias': torch.tensor([1.0]),
+        f'{prefix}.layer2.and.weight': torch.tensor([1.0, 1.0]),
+        f'{prefix}.layer2.and.bias': torch.tensor([-2.0]),
+    }
+
+weights = {}
+weights.update(xor_block('xor1'))
+weights.update(xor_block('xor2'))
+weights.update(xor_block('xor3'))
+
+save_file(weights, 'model.safetensors')
+mag = sum(t.abs().sum().item() for t in weights.values())
+print(f'Created model.safetensors (magnitude {mag:.0f})')

model.py

@@ -0,0 +1,50 @@
+"""
+Threshold Network for 4-input XOR Gate
+
+Cascade of three standard XORs (OR + NAND + AND structure).
+"""
+
+import torch
+from safetensors.torch import load_file
+
+
+def xor2(x1, x2, w, prefix):
+    inp = torch.tensor([float(x1), float(x2)])
+    or_out = int((inp * w[f'{prefix}.layer1.or.weight']).sum() + w[f'{prefix}.layer1.or.bias'] >= 0)
+    nand_out = int((inp * w[f'{prefix}.layer1.nand.weight']).sum() + w[f'{prefix}.layer1.nand.bias'] >= 0)
+    h = torch.tensor([float(or_out), float(nand_out)])
+    return int((h * w[f'{prefix}.layer2.and.weight']).sum() + w[f'{prefix}.layer2.and.bias'] >= 0)
+
+
+class ThresholdXOR4:
+    def __init__(self, weights_dict):
+        self.w = weights_dict
+
+    def __call__(self, a, b, c, d):
+        xor_ab = xor2(a, b, self.w, 'xor1')
+        xor_abc = xor2(xor_ab, c, self.w, 'xor2')
+        xor_abcd = xor2(xor_abc, d, self.w, 'xor3')
+        return float(xor_abcd)
+
+    @classmethod
+    def from_safetensors(cls, path="model.safetensors"):
+        return cls(load_file(path))
+
+
+if __name__ == "__main__":
+    weights = load_file("model.safetensors")
+    model = ThresholdXOR4(weights)
+
+    print("4-input XOR Gate:")
+    correct = 0
+    for a in [0, 1]:
+        for b in [0, 1]:
+            for c in [0, 1]:
+                for d in [0, 1]:
+                    out = int(model(a, b, c, d))
+                    expected = a ^ b ^ c ^ d
+                    if out == expected:
+                        correct += 1
+                    status = "OK" if out == expected else "FAIL"
+                    print(f"  XOR4({a},{b},{c},{d}) = {out} [{status}]")
+    print(f"Total: {correct}/16")

model.safetensors

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