Add D latch threshold circuit

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

.gitattributes

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

README.md

@@ -0,0 +1,88 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- sequential
+- latch
+---
+
+# threshold-d-latch
+
+D latch (level-sensitive) next-state logic as threshold circuit.
+
+## Circuit
+
+```
+E ───────┐
+D ───────┼──► D-Latch ──┬──► Q
+Q_prev ──┘             └──► Qn
+```
+
+## Modes
+
+- **E=1 (Transparent):** Q follows D
+- **E=0 (Hold):** Q holds previous value
+
+## Truth Table
+
+| E | D | Q_prev | Q | Qn | Mode |
+|---|---|--------|---|----|----|
+| 0 | X | 0 | 0 | 1 | Hold |
+| 0 | X | 1 | 1 | 0 | Hold |
+| 1 | 0 | X | 0 | 1 | Transparent |
+| 1 | 1 | X | 1 | 0 | Transparent |
+
+## Logic
+
+```
+Q  = (E AND D) OR (NOT_E AND Q_prev)
+Qn = (E AND NOT_D) OR (NOT_E AND NOT_Q_prev)
+```
+
+## Architecture
+
+| Layer | Neurons |
+|-------|---------|
+| 1 | e_and_d, e_and_notd, note_and_qprev, note_and_notqprev |
+| 2 | Q, Qn |
+
+**Total: 6 neurons, 26 parameters, 2 layers**
+
+## D-Latch vs D-Flip-Flop
+
+- **D-Latch:** Level-sensitive. Q changes while E is high.
+- **D-Flip-Flop:** Edge-triggered. Q changes only on clock edge.
+
+D-latches are simpler but can cause timing issues (race conditions) if not carefully designed. Flip-flops are safer for synchronous designs.
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 3 |
+| Outputs | 2 |
+| Neurons | 6 |
+| Layers | 2 |
+| Parameters | 26 |
+| Magnitude | 18 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+
+w = load_file('model.safetensors')
+
+# Simulate latch behavior
+q = 0
+for e, d in [(1, 1), (1, 0), (0, 1), (0, 0)]:
+    q_next = compute(e, d, q, w)
+    q = q_next
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-d-latch",
+  "description": "D latch (level-sensitive)",
+  "inputs": 3,
+  "outputs": 2,
+  "neurons": 6,
+  "layers": 2,
+  "parameters": 26
+}

create_safetensors.py

@@ -0,0 +1,95 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+# D-Latch (level-sensitive)
+# Inputs: E (enable), D (data), Q_prev (previous state)
+# Outputs: Q, Qn
+#
+# When E=1: Q = D (transparent mode)
+# When E=0: Q = Q_prev (hold mode)
+#
+# Q = (E AND D) OR (NOT_E AND Q_prev)
+# Qn = (E AND NOT_D) OR (NOT_E AND NOT_Q_prev)
+
+# Layer 1: Compute intermediate terms directly from inputs
+# e_and_d = E AND D
+weights['e_and_d.weight'] = torch.tensor([[1.0, 1.0, 0.0]], dtype=torch.float32)
+weights['e_and_d.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# e_and_notd = E AND NOT_D
+weights['e_and_notd.weight'] = torch.tensor([[1.0, -1.0, 0.0]], dtype=torch.float32)
+weights['e_and_notd.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# note_and_qprev = NOT_E AND Q_prev
+weights['note_and_qprev.weight'] = torch.tensor([[-1.0, 0.0, 1.0]], dtype=torch.float32)
+weights['note_and_qprev.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# note_and_notqprev = NOT_E AND NOT_Q_prev
+weights['note_and_notqprev.weight'] = torch.tensor([[-1.0, 0.0, -1.0]], dtype=torch.float32)
+weights['note_and_notqprev.bias'] = torch.tensor([0.0], dtype=torch.float32)
+
+# Layer 2: Combine for outputs
+# Q = OR(e_and_d, note_and_qprev)
+weights['q.weight'] = torch.tensor([[1.0, 0.0, 1.0, 0.0]], dtype=torch.float32)
+weights['q.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# Qn = OR(e_and_notd, note_and_notqprev)
+weights['qn.weight'] = torch.tensor([[0.0, 1.0, 0.0, 1.0]], dtype=torch.float32)
+weights['qn.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+save_file(weights, 'model.safetensors')
+
+def d_latch(e, d, q_prev):
+    inp = torch.tensor([float(e), float(d), float(q_prev)])
+
+    # Layer 1
+    e_and_d = int((inp @ weights['e_and_d.weight'].T + weights['e_and_d.bias'] >= 0).item())
+    e_and_notd = int((inp @ weights['e_and_notd.weight'].T + weights['e_and_notd.bias'] >= 0).item())
+    note_and_qprev = int((inp @ weights['note_and_qprev.weight'].T + weights['note_and_qprev.bias'] >= 0).item())
+    note_and_notqprev = int((inp @ weights['note_and_notqprev.weight'].T + weights['note_and_notqprev.bias'] >= 0).item())
+
+    # Layer 2
+    l1 = torch.tensor([float(e_and_d), float(e_and_notd), float(note_and_qprev), float(note_and_notqprev)])
+    q = int((l1 @ weights['q.weight'].T + weights['q.bias'] >= 0).item())
+    qn = int((l1 @ weights['qn.weight'].T + weights['qn.bias'] >= 0).item())
+
+    return q, qn
+
+def reference_d_latch(e, d, q_prev):
+    if e == 1:
+        return d, 1 - d
+    else:
+        return q_prev, 1 - q_prev
+
+print("Verifying D-Latch...")
+errors = 0
+for e in range(2):
+    for d in range(2):
+        for q_prev in range(2):
+            result = d_latch(e, d, q_prev)
+            expected = reference_d_latch(e, d, q_prev)
+            if result != expected:
+                errors += 1
+                print(f"ERROR: E={e}, D={d}, Q_prev={q_prev} -> {result}, expected {expected}")
+
+if errors == 0:
+    print("All 8 test cases passed!")
+else:
+    print(f"FAILED: {errors} errors")
+
+print("\nTruth Table:")
+print("E D Q_prev | Q Qn | Mode")
+print("-" * 30)
+for e in range(2):
+    for d in range(2):
+        for q_prev in range(2):
+            q, qn = d_latch(e, d, q_prev)
+            mode = "Transparent" if e == 1 else "Hold"
+            print(f"{e} {d}   {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 d_latch(e, d, q_prev, weights):
+    """D-Latch: E=1 transparent (Q=D), E=0 hold (Q=Q_prev)."""
+    inp = torch.tensor([float(e), float(d), float(q_prev)])
+
+    e_and_d = int((inp @ weights['e_and_d.weight'].T + weights['e_and_d.bias'] >= 0).item())
+    e_and_notd = int((inp @ weights['e_and_notd.weight'].T + weights['e_and_notd.bias'] >= 0).item())
+    note_and_qprev = int((inp @ weights['note_and_qprev.weight'].T + weights['note_and_qprev.bias'] >= 0).item())
+    note_and_notqprev = int((inp @ weights['note_and_notqprev.weight'].T + weights['note_and_notqprev.bias'] >= 0).item())
+
+    l1 = torch.tensor([float(e_and_d), float(e_and_notd), float(note_and_qprev), float(note_and_notqprev)])
+    q = int((l1 @ weights['q.weight'].T + weights['q.bias'] >= 0).item())
+    qn = int((l1 @ weights['qn.weight'].T + weights['qn.bias'] >= 0).item())
+
+    return q, qn
+
+if __name__ == '__main__':
+    w = load_model()
+    print('D-Latch:')
+    print('E D Q_prev | Q Qn')
+    for e in range(2):
+        for d in range(2):
+            for q_prev in range(2):
+                q, qn = d_latch(e, d, q_prev, w)
+                print(f'{e} {d}   {q_prev}    | {q}  {qn}')

model.safetensors

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