Add T flip-flop threshold circuit

6 neurons, 2 layers, 18 parameters, magnitude 19.

.gitattributes

@@ -0,0 +1 @@
+*.safetensors filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,112 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- sequential
+- flipflop
+---
+
+# threshold-t-flipflop
+
+T flip-flop (toggle) next-state logic as threshold circuit.
+
+## Circuit
+
+```
+T ───────┐
+Q_prev ──┴──► T-FF ──┬──► Q
+                    └──► Qn
+```
+
+## Modes
+
+- **T=0 (Hold):** Q stays same
+- **T=1 (Toggle):** Q flips
+
+## Truth Table
+
+| T | Q_prev | Q | Qn | Mode |
+|---|--------|---|----|----|
+| 0 | 0 | 0 | 1 | Hold |
+| 0 | 1 | 1 | 0 | Hold |
+| 1 | 0 | 1 | 0 | Toggle |
+| 1 | 1 | 0 | 1 | Toggle |
+
+## Logic
+
+```
+Q  = T XOR Q_prev
+Qn = T XNOR Q_prev
+```
+
+XOR is not linearly separable (the classic Minsky/Papert result), requiring 2 layers.
+
+## Architecture
+
+```
+    T      Q_prev
+    │        │
+    ├────┬───┤
+    │    │   │
+    ▼    ▼   ▼
+  ┌────┬────┬────┬────┐
+  │ OR │NAND│NOR │AND │   Layer 1
+  └────┴────┴────┴────┘
+    │    │    │    │
+    └─┬──┘    └─┬──┘
+      │         │
+      ▼         ▼
+   ┌─────┐   ┌─────┐
+   │ AND │   │ OR  │      Layer 2
+   └─────┘   └─────┘
+      │         │
+      ▼         ▼
+      Q        Qn
+```
+
+- Q = AND(OR, NAND) = XOR
+- Qn = OR(NOR, AND) = XNOR
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 2 |
+| Outputs | 2 |
+| Neurons | 6 |
+| Layers | 2 |
+| Parameters | 18 |
+| Magnitude | 19 |
+
+## Application: Binary Counter
+
+T flip-flops with T=1 create divide-by-2 counters:
+
+```python
+q = 0
+for _ in range(8):
+    q = t_flipflop(1, q)  # toggles: 0,1,0,1,0,1,0,1
+```
+
+Chain multiple T flip-flops for multi-bit counters.
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+
+w = load_file('model.safetensors')
+
+# Toggle mode creates oscillation
+q = 0
+for _ in range(4):
+    q_next = compute(t=1, q_prev=q, w)
+    q = q_next  # 0 -> 1 -> 0 -> 1
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-t-flipflop",
+  "description": "T flip-flop (toggle)",
+  "inputs": 2,
+  "outputs": 2,
+  "neurons": 6,
+  "layers": 2,
+  "parameters": 18
+}

create_safetensors.py

@@ -0,0 +1,104 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+# T Flip-Flop (Toggle)
+# Inputs: T (toggle), Q_prev (previous state)
+# Outputs: Q, Qn
+#
+# When T=1: Q toggles (Q = NOT Q_prev)
+# When T=0: Q holds (Q = Q_prev)
+#
+# Q = T XOR Q_prev = (T AND NOT_Q_prev) OR (NOT_T AND Q_prev)
+# Qn = NOT Q
+#
+# XOR is not linearly separable, requires 2 layers:
+# XOR(a,b) = AND(OR(a,b), NAND(a,b))
+
+# Layer 1: OR and NAND for Q, and for Qn
+# OR(T, Q_prev)
+weights['or.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['or.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# NAND(T, Q_prev)
+weights['nand.weight'] = torch.tensor([[-1.0, -1.0]], dtype=torch.float32)
+weights['nand.bias'] = torch.tensor([1.0], dtype=torch.float32)
+
+# For Qn = NOT(T XOR Q_prev) = XNOR(T, Q_prev) = (NOT_T AND NOT_Q_prev) OR (T AND Q_prev)
+# XNOR = AND(OR(NOT_T, NOT_Q_prev), NAND(NOT_T, NOT_Q_prev))
+#      = AND(NAND(T, Q_prev), OR(T, Q_prev))... wait, that's not right
+# Let me think: XNOR(a,b) = NOT XOR(a,b) = NOR(a,b) OR AND(a,b)
+# Actually: XNOR = (a AND b) OR (NOT_a AND NOT_b)
+# Which in threshold: we need NOR and AND, then OR them
+# NOR(T, Q_prev): fires when both are 0
+weights['nor.weight'] = torch.tensor([[-1.0, -1.0]], dtype=torch.float32)
+weights['nor.bias'] = torch.tensor([0.0], dtype=torch.float32)
+
+# AND(T, Q_prev): fires when both are 1
+weights['and.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['and.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# Layer 2: Combine
+# Q = AND(OR, NAND) = XOR
+weights['q.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['q.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# Qn = OR(NOR, AND) = XNOR
+weights['qn.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['qn.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+save_file(weights, 'model.safetensors')
+
+def t_flipflop(t, q_prev):
+    inp = torch.tensor([float(t), float(q_prev)])
+
+    # Layer 1
+    or_out = int((inp @ weights['or.weight'].T + weights['or.bias'] >= 0).item())
+    nand_out = int((inp @ weights['nand.weight'].T + weights['nand.bias'] >= 0).item())
+    nor_out = int((inp @ weights['nor.weight'].T + weights['nor.bias'] >= 0).item())
+    and_out = int((inp @ weights['and.weight'].T + weights['and.bias'] >= 0).item())
+
+    # Layer 2
+    l1_q = torch.tensor([float(or_out), float(nand_out)])
+    q = int((l1_q @ weights['q.weight'].T + weights['q.bias'] >= 0).item())
+
+    l1_qn = torch.tensor([float(nor_out), float(and_out)])
+    qn = int((l1_qn @ weights['qn.weight'].T + weights['qn.bias'] >= 0).item())
+
+    return q, qn
+
+def reference_t_ff(t, q_prev):
+    if t == 1:
+        return 1 - q_prev, q_prev
+    else:
+        return q_prev, 1 - q_prev
+
+print("Verifying T Flip-Flop...")
+errors = 0
+for t in range(2):
+    for q_prev in range(2):
+        result = t_flipflop(t, q_prev)
+        expected = reference_t_ff(t, q_prev)
+        if result != expected:
+            errors += 1
+            print(f"ERROR: T={t}, Q_prev={q_prev} -> {result}, expected {expected}")
+
+if errors == 0:
+    print("All 4 test cases passed!")
+else:
+    print(f"FAILED: {errors} errors")
+
+print("\nTruth Table:")
+print("T Q_prev | Q Qn | Mode")
+print("-" * 25)
+for t in range(2):
+    for q_prev in range(2):
+        q, qn = t_flipflop(t, q_prev)
+        mode = "Toggle" if t == 1 else "Hold"
+        print(f"{t}   {q_prev}   | {q}  {qn} | {mode}")
+
+mag = sum(t.abs().sum().item() for t in weights.values())
+print(f"\nMagnitude: {mag:.0f}")
+print(f"Parameters: {sum(t.numel() for t in weights.values())}")
+print(f"Neurons: {len([k for k in weights.keys() if 'weight' in k])}")

model.py

@@ -0,0 +1,30 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def t_flipflop(t, q_prev, weights):
+    """T Flip-Flop: T=1 toggles, T=0 holds."""
+    inp = torch.tensor([float(t), float(q_prev)])
+
+    or_out = int((inp @ weights['or.weight'].T + weights['or.bias'] >= 0).item())
+    nand_out = int((inp @ weights['nand.weight'].T + weights['nand.bias'] >= 0).item())
+    nor_out = int((inp @ weights['nor.weight'].T + weights['nor.bias'] >= 0).item())
+    and_out = int((inp @ weights['and.weight'].T + weights['and.bias'] >= 0).item())
+
+    l1_q = torch.tensor([float(or_out), float(nand_out)])
+    q = int((l1_q @ weights['q.weight'].T + weights['q.bias'] >= 0).item())
+
+    l1_qn = torch.tensor([float(nor_out), float(and_out)])
+    qn = int((l1_qn @ weights['qn.weight'].T + weights['qn.bias'] >= 0).item())
+
+    return q, qn
+
+if __name__ == '__main__':
+    w = load_model()
+    print('T Flip-Flop (counter demo):')
+    q = 0
+    for i in range(8):
+        print(f'  Step {i}: Q={q}')
+        q, _ = t_flipflop(1, q, w)  # Always toggle

model.safetensors

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