The Ternary Trio:
CONS, ACONS, and TIMPL

Every processor has comparison instructions. Binary architectures give you XOR to detect differences and a subtractor to determine direction. That's two operations for two pieces of information. Balanced ternary can do better, because each trit carries three states: negative, zero, positive. The Setnex ISA exploits this with three trit-parallel primitives—CONS, ACONS, and TCMP—plus a configurable implication operator, TIMPL, that has no equivalent in binary at all.

This article explains what they do, why they form a complete toolkit, and where they could matter in practice.

Three ways to compare two trits

Consider two 27-trit words, A and B. At each position i, the trits A[i] and B[i] are drawn from {N, Z, P}. Three natural questions arise:

What do they agree on? That's CONS (consensus). If A[i] and B[i] are the same, return that value. If they differ, return Z—"no agreement."

What's missing? That's ACONS (anti-consensus). If A[i] and B[i] are the same, return Z—"nothing is missing." If they differ, return the third trit, the one that neither A nor B contributed.

Who dominates? That's TCMP (ternary compare). Return the sign of A[i] − B[i]: N if A[i] is less, Z if equal, P if A[i] is greater.

Notice how they partition the information differently. CONS tells you what is shared. ACONS tells you what's absent. TCMP tells you who's on top. Together, they extract every possible relation between two trit-parallel vectors in three instructions.

The Z ambiguity and why TCMP matters

CONS has a blind spot: CONS(Z, Z) = Z, but CONS(N, P) = Z too. The output Z means either "both agree on zero" or "they disagree." You can't tell which. TCMP resolves this: if TCMP gives Z, it's genuine agreement. If TCMP gives N or P, the Z from CONS was a disagreement. The two operations are not redundant—they're complementary.

The binary comparison

In binary, XOR detects differences (0 = same, 1 = different). That's a single bit of information per position. To get the direction of the difference, you need a subtractor or additional logic. There is no "absent value" concept at all—with only two states, if you know one and it's different, the other is determined.

TIMPL: the instruction with five personalities

CONS, ACONS, and TCMP are pure arithmetic—they behave the same regardless of configuration. TIMPL is different. It computes the ternary implication A ⇒ B, and its truth table changes based on the LMODE register and STATUS.lx trit. Same opcode, same operands, five different semantics.

The highlighted cells show where the modes diverge. Five philosophies about what the indeterminate value Z means.

In Kleene mode, IMPL(Z, Z) = Z: indeterminate implies indeterminate is itself indeterminate. In Łukasiewicz, IMPL(Z, Z) = P: if the premise is "unknown" and the conclusion is "unknown," the implication holds—you can't violate a rule you can't evaluate. In Heyting, IMPL(Z, N) = N: unknown combined with false is false—the most conservative stance. In RM3, IMPL(P, Z) = N: contradictions don't propagate as truth. In B3, any contact with Z produces Z—meaninglessness is infectious.

Łukasiewicz TIMPL as an order test

In Łukasiewicz mode, TIMPL has a clean algebraic interpretation: IMPL(a, b) = min(P, −a + b + 1). The result is P if and only if a ≤ b in the natural trit ordering N < Z < P. This makes TIMPL a trit-parallel subsumption test: if every trit of the result is P, then A ≤ B at every position.

Potential applications

CONS  tmp, A, B       # agreement between A and B, or Z
CONS  vote, tmp, C    # if A=B, they win; else C decides
TCMP  faultA, A, vote # nonzero trits = where A diverges
TCMP  faultB, B, vote # nonzero trits = where B diverges
ACONS repair, A, B    # the missing trit repairs the faulty replica

TCMP  diff, old, new  # N = decreased, Z = unchanged, P = increased

TIMPL mono, old, new  # Łukasiewicz: P iff old[i] ≤ new[i]
# if all trits are P → monotone; non-P trits = violations

TIMPL check, required, user_caps  # Łukasiewicz mode
# check[i] = P iff required[i] ≤ user_caps[i]
# all-P → access granted

TIMPL valid, constraints, data  # Kleene mode
# valid[i] = P if constraint holds
#          = Z if either side is NULL → inconclusive
#          = N if constraint is violated

The bigger picture

None of these applications are impossible in binary. Everything that runs on a ternary processor can be compiled for x86. The question is density: how many instructions does a given pattern take?

The gains are modest in raw instruction count—2× to 3×, not 10×. But they're structural: patterns that require multi-pass logic in binary reduce to single-pass primitives in ternary. And TIMPL's configurable semantics via LMODE has no binary equivalent at all. You'd need different code paths, not different register values.

The honest assessment: these advantages exist on paper. No ternary processor has been built at scale since the Soviet Setun in 1958. The Setnex ISA is a specification, not silicon. Whether the instruction density gains translate to real-world performance depends on workloads, compiler quality, and the eventual hardware implementation. But the mathematical foundation is clean and the gate-level cost is low.