---
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