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:

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

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