@NUTSHELL Tetrazine

Tetrazine is a rule I devised that is a 'fusion' of many different wire-like rules. It steals properties from:
* Wireworld++ => tiny AND/XOR gates
* NoTimeAtAll => stagnating signals
* DECA => tiny AND/ANDNOT gates

States:

0: {Background} background
1: {StrongHead} strong head
2: {StrongTail} strong tail
3: {StrongWire} strong wire
4: {WeakHead} weak head
5: {WeakTail} weak tail
6: {WeakWire} weak wire
7: {NTAAHead1} NTAA head 1
8: {NTAAHead0} NTAA head 0
9: {NTAATail} NTAA tail
10: {NTAAWire} NTAA wire
11: {DECA1} DECA blocker head 1
12: {DECA0} DECA blocker head 0


@TABLE
neighborhood: Moore
anyNTAAHead = (NTAAHead0, NTAAHead1)
anyhead = (StrongHead, WeakHead, anyNTAAHead)
WWTail = (WeakTail, StrongTail)
anyWW = (anyhead, WeakWire, StrongWire)
anyNTAA = (anyNTAAHead, NTAATail, NTAAWire)

# --------------DECA---------------

symmetries: rotate4reflect
# blocked by adjacent DECA head1
(WeakWire, StrongWire), N Background, E (WeakWire, StrongWire), S DECA1, W anyhead; [0]

# toggle when lone head next to
(DECA0, DECA1), NW --anyWW, N (anyhead, NTAATail, StrongTail), NE --anyWW; [0: (DECA1, DECA0)]

# --------------NTAA--------------
# 0: blank
# 1: wire {w}
# 2: wire 0 {h0}
# 3: wire 1 {h1}
# 4: tail {t}

# h = (h0, h1)
# ht = (h, t)
# wht = (w, ht)
# wt = (w, t)

symmetries: nutshell.AlternatingPermute
# NEVER put a head where there would be an adjacent tail
# w, t, any ~ 3; w
NTAAWire, NTAATail, any ~ 4, any ~ 3; NTAAWire

symmetries: rotate4reflect
# Split at T
# w, w, h, w, --wht; [2]
NTAAWire, N NTAAWire, E anyNTAAHead, S NTAAWire, W --anyNTAA; [E]

symmetries: nutshell.AlternatingPermute
# Signals wait at intersections
# w, w ~ 2, any ~ 2; w
NTAAWire, NTAAWire ~ 2, any ~ 4, any ~ 2; NTAAWire

# Sum=1 signal combination
# w, h1, h1, any ~ 2; h0
NTAAWire, NTAAHead1 ~ 2, any ~ 4, any ~ 2; NTAAHead0

# w, h, h0, --h1 ~ 2; [1]
NTAAWire, anyNTAAHead, any ~ 2, NTAAHead0, any ~ 2, --NTAAHead1 ~ 2; [1]

# Signals
# w, h, --h ~ 3; [1]
NTAAWire, anyNTAAHead, any ~ 2, --anyNTAAHead ~ 3, any ~ 2; [1]
# h, --w ~ 4; t
anyNTAAHead, --NTAAWire ~ 4, any ~ 4; NTAATail
# t, --h ~ 4; w
NTAATail, --anyNTAAHead ~ 4, any ~ 4; NTAAWire

# -----------------Wireworld++-----------------

symmetries: permute
# prevent backfiring when transitioning into NTAA wire
(StrongTail, WeakTail), NTAAHead1 ~ 1, any ~ 7; [0]
# wireworld heads go immediately to tail
(StrongHead, StrongTail), any; [0: (StrongTail, StrongWire)]
(WeakHead, WeakTail), any; [0: (WeakTail, WeakWire)]
# wireworld++ transitions
StrongWire, <12 / (StrongHead, NTAAHead1) / any - (StrongHead, NTAAHead1)>; StrongHead
StrongWire, <2 / (WeakHead, NTAAHead1) / any - (WeakHead, NTAAHead1)>; StrongHead
WeakWire, <12 / (WeakHead, NTAAHead1) / any - (WeakHead, NTAAHead1)>; WeakHead
WeakWire, <1 / (StrongHead, NTAAHead1) / any - (StrongHead, NTAAHead1)>; WeakHead

# ---------------some crossover------------

# activate when Wireworld++heads
symmetries: permute
NTAAWire, (anyhead - anyNTAA) ~ 2, any; NTAAHead1
NTAAWire, (anyhead - anyNTAA) ~ 1, any; NTAAHead0

@COLORS

000: Background
090: StrongHead
060: StrongTail 
030: StrongWire
990: WeakHead
660: WeakTail
003: WeakWire
099: NTAAHead1
033: NTAAHead0
600: NTAATail
300: NTAAWire
333: DECA0
999: DECA1