Initial commit: 4-input AND threshold gate

Single-neuron circuit with weights [1,1,1,1] and bias -4.
Magnitude 8, verified 16/16 inputs correct.

README.md

@@ -0,0 +1,102 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+---
+
+# threshold-and4
+
+A 4-of-4 threshold gate. All four inputs must be active to reach the firing threshold.
+
+## Circuit
+
+```
+  x1  x2  x3  x4
+   │   │   │   │
+   └───┴───┴───┘
+         │
+         ▼
+    ┌─────────┐
+    │w: 1,1,1,1│
+    │ b: -4   │
+    └─────────┘
+         │
+         ▼
+   AND4(x1,x2,x3,x4)
+```
+
+## Mechanism
+
+Each input contributes +1 to the sum. The bias of -4 means exactly four contributions are required to reach zero:
+
+| x1 | x2 | x3 | x4 | sum | output |
+|----|----|----|-----|-----|--------|
+| 0 | 0 | 0 | 0 | -4 | 0 |
+| 0 | 0 | 0 | 1 | -3 | 0 |
+| ... | ... | ... | ... | ... | 0 |
+| 1 | 1 | 1 | 0 | -1 | 0 |
+| 1 | 1 | 1 | 1 | 0 | 1 |
+
+Only the all-ones input reaches the threshold.
+
+## Parameters
+
+| | |
+|---|---|
+| Weights | [1, 1, 1, 1] |
+| Bias | -4 |
+| Magnitude | 8 |
+| Total | 5 parameters |
+
+## Optimality
+
+This circuit is at minimum magnitude (8). The pattern generalizes: n-input AND requires weights all 1 and bias -n, giving magnitude 2n.
+
+| Gate | Weights | Bias | Magnitude |
+|------|---------|------|-----------|
+| AND2 | [1, 1] | -2 | 4 |
+| AND3 | [1, 1, 1] | -3 | 6 |
+| AND4 | [1, 1, 1, 1] | -4 | 8 |
+| ANDn | [1, ..., 1] | -n | 2n |
+
+## Properties
+
+- Linearly separable (single neuron suffices)
+- Commutative, associative, idempotent
+- De Morgan dual: AND4(x1,x2,x3,x4) = NOT(OR4(NOT(x1), NOT(x2), NOT(x3), NOT(x4)))
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def and4_gate(x1, x2, x3, x4):
+    inputs = torch.tensor([float(x1), float(x2), float(x3), float(x4)])
+    return int((inputs * w['weight']).sum() + w['bias'] >= 0)
+
+# Test
+assert and4_gate(1, 1, 1, 1) == 1
+assert and4_gate(1, 1, 1, 0) == 0
+assert and4_gate(0, 0, 0, 0) == 0
+```
+
+## Files
+
+```
+threshold-and4/
+├── model.safetensors
+├── model.py
+├── config.json
+├── create_safetensors.py
+└── README.md
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,19 @@
+{
+  "model_type": "threshold_network",
+  "task": "and4_gate",
+  "architecture": "4 -> 1",
+  "input_size": 4,
+  "output_size": 1,
+  "num_neurons": 1,
+  "num_parameters": 5,
+  "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,13 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {
+    'weight': torch.tensor([1.0, 1.0, 1.0, 1.0]),
+    'bias': torch.tensor([-4.0]),
+}
+
+save_file(weights, 'model.safetensors')
+print('Created model.safetensors')
+print(f'  weight: {weights["weight"].tolist()}')
+print(f'  bias: {weights["bias"].item()}')
+print(f'  magnitude: {sum(abs(w) for w in weights["weight"].tolist()) + abs(weights["bias"].item()):.0f}')

model.py

@@ -0,0 +1,67 @@
+"""
+Threshold Network for 4-input AND Gate
+
+A formally verified single-neuron threshold network computing 4-way logical conjunction.
+Weights are integer-constrained and activation uses the Heaviside step function.
+"""
+
+import torch
+from safetensors.torch import load_file
+
+
+class ThresholdAND4:
+    """
+    4-input AND gate implemented as a threshold neuron.
+
+    Circuit: output = (w1*x1 + w2*x2 + w3*x3 + w4*x4 + bias >= 0)
+    With weights=[1,1,1,1], bias=-4: only (1,1,1,1) reaches threshold.
+    """
+
+    def __init__(self, weights_dict):
+        self.weight = weights_dict['weight']
+        self.bias = weights_dict['bias']
+
+    def __call__(self, x1, x2, x3, x4):
+        inputs = torch.tensor([float(x1), float(x2), float(x3), float(x4)])
+        weighted_sum = (inputs * self.weight).sum() + self.bias
+        return (weighted_sum >= 0).float()
+
+    @classmethod
+    def from_safetensors(cls, path="model.safetensors"):
+        return cls(load_file(path))
+
+
+def forward(x, weights):
+    """
+    Forward pass with Heaviside activation.
+
+    Args:
+        x: Input tensor of shape [..., 4]
+        weights: Dict with 'weight' and 'bias' tensors
+
+    Returns:
+        AND(x[0], x[1], x[2], x[3])
+    """
+    x = torch.as_tensor(x, dtype=torch.float32)
+    weighted_sum = (x * weights['weight']).sum(dim=-1) + weights['bias']
+    return (weighted_sum >= 0).float()
+
+
+if __name__ == "__main__":
+    weights = load_file("model.safetensors")
+    model = ThresholdAND4(weights)
+
+    print("4-input AND Gate Truth Table:")
+    print("-" * 35)
+    correct = 0
+    for x1 in [0, 1]:
+        for x2 in [0, 1]:
+            for x3 in [0, 1]:
+                for x4 in [0, 1]:
+                    out = int(model(x1, x2, x3, x4).item())
+                    expected = x1 & x2 & x3 & x4
+                    status = "OK" if out == expected else "FAIL"
+                    if out == expected:
+                        correct += 1
+                    print(f"AND4({x1}, {x2}, {x3}, {x4}) = {out}  [{status}]")
+    print(f"\nTotal: {correct}/16 correct")