Transition Machines: Unifying Automata Models

• Transition Machines are a family of automata models with varying definitions, including Tsetlin Machines for logic-based learning, automata for non-Markovian control, and reactive Turing models.
• They leverage finite-state automata to learn human-interpretable propositional logic and achieve efficient pattern recognition with hardware implementations boasting high throughput and energy efficiency.
• Their applications span pattern recognition, reinforcement learning, and formal verification, while ongoing research addresses scalability, computational complexity, and context-dependent interpretations.

Transition Machines (TMs) designate several distinct machine formalisms in recent arXiv literature rather than a single standardized model. In one major lineage, TM denotes the Tsetlin Machine: a pattern-recognition framework that learns human-interpretable propositional logic from data using teams of finite-state Tsetlin automata. In another, TM denotes a Transition Machine introduced to capture transition-based non-Markovianity in deterministic partially observable environments. Related theoretical work also uses Turing-style models whose semantic object is a transition system or whose inputs contain uncertainty, notably Reactive Turing Machines and metastability-containing Turing Machines (Saha et al., 2021, Wu et al., 3 Aug 2025, Baeten et al., 2011, Bund et al., 19 Apr 2026). This plurality of meanings is itself technically important, because the common abbreviation conceals different notions of state, transition, output, and learnability.

1. Terminological scope

The literature covered here uses the same abbreviation for machine models with different roles. Tsetlin-machine papers explicitly note that “TM” denotes Tsetlin Machine rather than Turing Machine, and build logic-based learners from clauses, literals, and finite-state learning automata. The Det-POMDP paper introduces Transition Machines as automata whose outputs are next observations, complementing Reward Machines whose outputs are rewards. Process-theoretic work on Reactive Turing Machines treats a machine as an executor of labelled transition systems, while metastability-containing Turing Machines study closure over all concretizations of uncertain inputs (Granmo, 2023, Wu et al., 3 Aug 2025, Baeten et al., 2011, Bund et al., 19 Apr 2026).

TM usage	Core formal object	Representative source
Tsetlin Machine	Clause-based propositional learner built from finite-state automata	(Saha et al., 2021)
Transition Machine	Automaton with memory over labels and outputs in $O$ for next-observation prediction	(Wu et al., 3 Aug 2025)
Reactive Turing Machine	Turing Machine with labelled interaction and LTS semantics	(Baeten et al., 2011)
Metastability-containing TM	Turing Machine over $\{0,1,\bot\}$ computing closure over concretizations	(Bund et al., 19 Apr 2026)

A plausible implication is that the phrase “Transition Machines” must be interpreted strictly from local context: in logic-based ML it often points to Tsetlin-style clause systems, whereas in reinforcement learning it names a specific automaton family for transition non-Markovianity.

2. Propositional Tsetlin Machines

In the Tsetlin lineage, TMs are a pattern recognition approach that uses finite state machines for learning and propositional logic to represent patterns. The canonical input is a Boolean feature vector $X=(x_1,\ldots,x_f)$, augmented with negations to form the literal set $L=\{x_1,\ldots,x_f,\neg x_1,\ldots,\neg x_f\}$, with $\bar{x}_k=1-x_k$ used as notation for negation. Clauses are conjunctive pattern detectors,

$$C_j(X)=\bigwedge_{l_k\in L_j} l_k=\prod_{l_k\in L_j} l_k,$$

and a binary classifier aggregates evenly split positive and negative clause sets by

$$v(X)=\sum_{j=1}^{n/2} C_j^+(X)-\sum_{j=1}^{n/2} C_j^-(X), \qquad \hat y=u(v),$$

with $u(\cdot)$ the unit step function. An equivalent view is $\hat y=u(\sum_{j=1}^n w_j C_j(X))$ for $w_j\in\{+1,-1\}$ fixed by clause polarity. The framework is natively interpretable because the decision function is a globally readable set of conjunctive clauses, and locally readable because individual clause votes explain a specific input (Saha et al., 2021).

Learning is delegated to teams of Tsetlin automata, one automaton per literal per clause. Each automaton chooses Include or Exclude and is updated through stochastic feedback. Type I feedback produces frequent patterns and increases recall; Type II feedback increases discrimination and precision. The user-configurable parameters are $\{0,1,\bot\}$0 for specificity, $\{0,1,\bot\}$1 for the voting target, $\{0,1,\bot\}$2 for number of clauses, $\{0,1,\bot\}$3 for number of base features, and $\{0,1,\bot\}$4 for training rounds. For a dataset of size $\{0,1,\bot\}$5, $\{0,1,\bot\}$6 clauses, and $\{0,1,\bot\}$7 propositional features, the per-dataset computational cost is stated as

$\{0,1,\bot\}$8

with $\{0,1,\bot\}$9 the cost of bitwise AND, $X=(x_1,\ldots,x_f)$0 the cost of integer addition, and $X=(x_1,\ldots,x_f)$1 the cost of automaton state update (Saha et al., 2021).

A later deterministic variant, the Arbitrarily Deterministic TM, replaces standard Tsetlin automata with a Multi-Step Variable-Structure Finite-State Learning Automaton. Strong feedback uses $X=(x_1,\ldots,x_f)$2-step state jumps, weak feedback uses single-step transitions, and every $X=(x_1,\ldots,x_f)$3-th transition is stochastic with probability $X=(x_1,\ldots,x_f)$4. The paper states that $X=(x_1,\ldots,x_f)$5 makes every update random and $X=(x_1,\ldots,x_f)$6 makes the automaton completely deterministic. It further reports that random number generation accounts for $X=(x_1,\ldots,x_f)$7 of total system power in switching and $X=(x_1,\ldots,x_f)$8 in leakage, giving up to $X=(x_1,\ldots,x_f)$9 system power reduction potential, with “up to 11 mW” saved for larger datasets at high $L=\{x_1,\ldots,x_f,\neg x_1,\ldots,\neg x_f\}$0 values (Abeyrathna et al., 2020).

3. Relational and first-order Tsetlin Machines

The relational Tsetlin Machine lifts the propositional TM to first-order logic with Herbrand semantics. Let $L=\{x_1,\ldots,x_f,\neg x_1,\ldots,\neg x_f\}$1 be constants and $L=\{x_1,\ldots,x_f,\neg x_1,\ldots,\neg x_f\}$2 predicate symbols; then the Herbrand Base is the set of all ground atoms over $L=\{x_1,\ldots,x_f,\neg x_1,\ldots,\neg x_f\}$3 and $L=\{x_1,\ldots,x_f,\neg x_1,\ldots,\neg x_f\}$4, and the learned program consists of non-recursive Horn clauses. The semantic machinery is given through the immediate consequence operator $L=\{x_1,\ldots,x_f,\neg x_1,\ldots,\neg x_f\}$5 and the Least Herbrand Model $L=\{x_1,\ldots,x_f,\neg x_1,\ldots,\neg x_f\}$6, so that the learned machine returns a logic program rather than an unstructured classifier. The central motivation is natural language understanding and closed-domain question answering, where the machine learns rules that represent how actions and consequences are related in the real world (Saha et al., 2021).

The preprocessing pipeline is explicitly relational. Each sentence yields a relation instance; entities are typed; textual constants are replaced by instance-local placeholders; and constants are then detached into variables $L=\{x_1,\ldots,x_f,\neg x_1,\ldots,\neg x_f\}$7. This makes the number of propositional inputs scale with variables and arities, $L=\{x_1,\ldots,x_f,\neg x_1,\ldots,\neg x_f\}$8, rather than with the size of the constant domain. Free variables induce multiple permissible variable-to-constant assignments, so the machine generates all permissible permutations and applies a TM convolution operator over them. In the paper’s formulation, this operationalizes existential quantification by making a clause fire if any consistent assignment makes it true. Representative learned rules include

$L=\{x_1,\ldots,x_f,\neg x_1,\ldots,\neg x_f\}$9

and

$\bar{x}_k=1-x_k$0

For movement and location questions, the learned clauses capture that the latest $\bar{x}_k=1-x_k$1 determines the current location (Saha et al., 2021).

The empirical claims are unusually concrete. On closed-domain QA, the first-order representation produces $\bar{x}_k=1-x_k$2 more compact KBs and increases answering accuracy from $\bar{x}_k=1-x_k$3 to $\bar{x}_k=1-x_k$4. Under injected noise of $\bar{x}_k=1-x_k$5, $\bar{x}_k=1-x_k$6, $\bar{x}_k=1-x_k$7, and $\bar{x}_k=1-x_k$8, test accuracy degrades from $\bar{x}_k=1-x_k$9 to $$C_j(X)=\bigwedge_{l_k\in L_j} l_k=\prod_{l_k\in L_j} l_k,$$0, $$C_j(X)=\bigwedge_{l_k\in L_j} l_k=\prod_{l_k\in L_j} l_k,$$1, $$C_j(X)=\bigwedge_{l_k\in L_j} l_k=\prod_{l_k\in L_j} l_k,$$2, and $$C_j(X)=\bigwedge_{l_k\in L_j} l_k=\prod_{l_k\in L_j} l_k,$$3, respectively. The same paper states that convolution can reduce the number of clauses needed by up to $$C_j(X)=\bigwedge_{l_k\in L_j} l_k=\prod_{l_k\in L_j} l_k,$$4, offsetting the $$C_j(X)=\bigwedge_{l_k\in L_j} l_k=\prod_{l_k\in L_j} l_k,$$5 overhead from free-variable permutations. The stated limitations are equally specific: the pipeline assumes simple sentences with one relation per sentence, the learned program uses non-recursive Horn clauses, and scalability to open-domain QA depends on robust relation extraction, entity typing, and management of large predicate signatures (Saha et al., 2021).

4. Shared-clause, composite, and application-oriented Tsetlin systems

A separate development addresses multi-output and specialist collaboration. The coalesced multi-output Tsetlin Machine merges multiple TMs into a single clause pool with integer weights $$C_j(X)=\bigwedge_{l_k\in L_j} l_k=\prod_{l_k\in L_j} l_k,$$6, so that shared clause outputs $$C_j(X)=\bigwedge_{l_k\in L_j} l_k=\prod_{l_k\in L_j} l_k,$$7 are aggregated by

$$C_j(X)=\bigwedge_{l_k\in L_j} l_k=\prod_{l_k\in L_j} l_k,$$8

Positive weights vote for output $$C_j(X)=\bigwedge_{l_k\in L_j} l_k=\prod_{l_k\in L_j} l_k,$$9, negative weights vote for output $$v(X)=\sum_{j=1}^{n/2} C_j^+(X)-\sum_{j=1}^{n/2} C_j^-(X), \qquad \hat y=u(v),$$0, and both clause composition and weights are learned jointly through interacting Stochastic Searching on the Line and Tsetlin-automata teams. The point of the construction is that separate TMs operate in silos, whereas clause sharing enables pattern reuse across outputs (Glimsdal et al., 2021).

The empirical pattern is that sharing helps most at low and moderate clause budgets. For $$v(X)=\sum_{j=1}^{n/2} C_j^+(X)-\sum_{j=1}^{n/2} C_j^-(X), \qquad \hat y=u(v),$$1 clauses per class, the reported accuracies are $$v(X)=\sum_{j=1}^{n/2} C_j^+(X)-\sum_{j=1}^{n/2} C_j^-(X), \qquad \hat y=u(v),$$2 vs $$v(X)=\sum_{j=1}^{n/2} C_j^+(X)-\sum_{j=1}^{n/2} C_j^-(X), \qquad \hat y=u(v),$$3 on Fashion-MNIST and $$v(X)=\sum_{j=1}^{n/2} C_j^+(X)-\sum_{j=1}^{n/2} C_j^-(X), \qquad \hat y=u(v),$$4 vs $$v(X)=\sum_{j=1}^{n/2} C_j^+(X)-\sum_{j=1}^{n/2} C_j^-(X), \qquad \hat y=u(v),$$5 on Kuzushiji-MNIST for Weighted TM versus CoTM. At $$v(X)=\sum_{j=1}^{n/2} C_j^+(X)-\sum_{j=1}^{n/2} C_j^-(X), \qquad \hat y=u(v),$$6K clauses per class on MNIST, CoTM reaches $$v(X)=\sum_{j=1}^{n/2} C_j^+(X)-\sum_{j=1}^{n/2} C_j^-(X), \qquad \hat y=u(v),$$7 test accuracy by epoch $$v(X)=\sum_{j=1}^{n/2} C_j^+(X)-\sum_{j=1}^{n/2} C_j^-(X), \qquad \hat y=u(v),$$8, while Weighted TM reaches the same level at epoch $$v(X)=\sum_{j=1}^{n/2} C_j^+(X)-\sum_{j=1}^{n/2} C_j^-(X), \qquad \hat y=u(v),$$9, which the paper summarizes as $u(\cdot)$0 faster. On imbalanced IMDb data, removing positive-sentiment training examples from fraction $u(\cdot)$1 to $u(\cdot)$2 yields a test-accuracy drop $u(\cdot)$3 of $u(\cdot)$4 to $u(\cdot)$5 percentage points versus $u(\cdot)$6 of $u(\cdot)$7 to only $u(\cdot)$8 (Glimsdal et al., 2021).

TMComposites pursue a different route: independent specialist Tsetlin Machines are trained on different Booleanizations of the same input and combined at inference by normalized class sums. For TM $u(\cdot)$9, the per-expert normalization constant is

$\hat y=u(\sum_{j=1}^n w_j C_j(X))$0

and the composite decision rule is

$\hat y=u(\sum_{j=1}^n w_j C_j(X))$1

The specialists implemented are Adaptive Gaussian Thresholding, Color Thermometers, and HOG. After $\hat y=u(\sum_{j=1}^n w_j C_j(X))$2 epochs, the four-member composite reaches $\hat y=u(\sum_{j=1}^n w_j C_j(X))$3 on CIFAR-10, $\hat y=u(\sum_{j=1}^n w_j C_j(X))$4 on CIFAR-100, and $\hat y=u(\sum_{j=1}^n w_j C_j(X))$5 on Fashion-MNIST, corresponding to gains of $\hat y=u(\sum_{j=1}^n w_j C_j(X))$6, $\hat y=u(\sum_{j=1}^n w_j C_j(X))$7, and $\hat y=u(\sum_{j=1}^n w_j C_j(X))$8 over the best single specialist in each case. The paper further states that sorting CIFAR-100 test images by $\hat y=u(\sum_{j=1}^n w_j C_j(X))$9 yields monotonically increasing accuracy, reaching $w_j\in\{+1,-1\}$0 at the high-confidence end (Granmo, 2023).

Tsetlin Machines have also been adapted to recommendation systems. One study develops a multi-class TM over $w_j\in\{+1,-1\}$1 output classes with $w_j\in\{+1,-1\}$2 clauses per class and compares it with a five-layer feed-forward network on the H&M Personalized Fashion Recommendations dataset. The reported scores are $w_j\in\{+1,-1\}$3, $w_j\in\{+1,-1\}$4, and $w_j\in\{+1,-1\}$5 for the TM, versus $w_j\in\{+1,-1\}$6, $w_j\in\{+1,-1\}$7, and $w_j\in\{+1,-1\}$8 for the neural baseline. The same study, however, emphasizes scaling limits: the CUDA TM implementation scales almost constantly in the number of clauses, yet time and memory become problematic at recommendation-system class counts, and the full item catalog could not be evaluated because of memory constraints (Borgersen et al., 2022).

5. Transition Machines for partially observable sequential decision-making

In reinforcement learning under partial observability, Transition Machines are introduced as automata that encode transition-based non-Markovianity. The setting is a deterministic POMDP

$w_j\in\{+1,-1\}$9

with a labeling function $\{0,1,\bot\}$00. A Reward Machine is

$\{0,1,\bot\}$01

while a Transition Machine is

$\{0,1,\bot\}$02

where $\{0,1,\bot\}$03 updates latent memory from labels and $\{0,1,\bot\}$04 predicts the next observation. The paper’s key claim is that Reward Machines encode reward-based non-Markovianity but do not encode transition-based non-Markovianity; using only RMs can therefore produce unnatural problem formulations in POMDPs (Wu et al., 3 Aug 2025).

The unifying formalism is the Dual-Behavior Mealy Machine,

$\{0,1,\bot\}$05

with $\{0,1,\bot\}$06-inputs causing state transitions and $\{0,1,\bot\}$07-inputs producing outputs. DBMM subsumes both TM and RM by taking $\{0,1,\bot\}$08, $\{0,1,\bot\}$09, and choosing $\{0,1,\bot\}$10 for TMs or $\{0,1,\bot\}$11 for RMs. The learning algorithm, DB-RPNI, builds a Prefix Tree Transducer from traces and then applies red-blue state merging with local compatibility

$\{0,1,\bot\}$12

If the sample set is structure complete, DB-RPNI returns the minimal resolvent DBMM and runs in $\{0,1,\bot\}$13 time; in the general case it runs in $\{0,1,\bot\}$14 time (Wu et al., 3 Aug 2025).

The operational goal is to restore Markovian structure by augmenting observations with automaton states. If a TM is resolvent, then $\{0,1,\bot\}$15 makes the next observation deterministic, with

$\{0,1,\bot\}$16

The paper’s four-rooms example makes the distinction concrete: moving up from corridor leads to cyanroom only if the key was previously acquired, whereas reward depends on sitting on the sofa after reaching the toilet. The inferred automata recover these two histories separately. Experimentally, inference time is $\{0,1,\bot\}$17s versus $\{0,1,\bot\}$18s and $\{0,1,\bot\}$19s on $\{0,1,\bot\}$20 grids, $\{0,1,\bot\}$21s versus $\{0,1,\bot\}$22s and $\{0,1,\bot\}$23s on $\{0,1,\bot\}$24 grids, and $\{0,1,\bot\}$25s with both baselines timing out on $\{0,1,\bot\}$26 grids, which the paper summarizes as speedups of up to three orders of magnitude. In a $\{0,1,\bot\}$27 ablation, the full pipeline infers $\{0,1,\bot\}$28 TM states and $\{0,1,\bot\}$29 RM states, while removing Observation Supplement makes RM states explode to $\{0,1,\bot\}$30 in the low-data setting (Wu et al., 3 Aug 2025).

6. Transition-system and Turing-machine interpretations

Reactive Turing Machines extend classical Turing Machines with interaction in the process-theoretic sense. An RTM is a quadruple

$\{0,1,\bot\}$31

with transition relation

$\{0,1,\bot\}$32

Its semantics is not a function but a labelled transition system whose states are configurations $\{0,1,\bot\}$33, whose transitions are labelled by observable actions or $\{0,1,\bot\}$34, and whose final states correspond to $\{0,1,\bot\}$35. On this basis, executability is defined as the property of being the transition-system semantics of some RTM (Baeten et al., 2011).

The main theorems characterize which transition systems are executable. Every computable transition system with bounded branching degree is simulated modulo divergence-preserving branching bisimilarity by an RTM, and every effective transition system is simulated modulo branching bisimilarity without divergence preservation. The paper further concludes that the parallel composition of communicating RTMs can be simulated by a single RTM. Universality is correspondingly stratified: there exist universal RTMs modulo branching bisimilarity, but modulo divergence-preserving branching bisimilarity universality holds only up to a fixed branching degree. The same work establishes a correspondence between executability and finite definability in a simple process calculus (Baeten et al., 2011).

Metastability-containing Turing Machines analyze Turing computation with uncertain input symbols $\{0,1,\bot\}$36. For $\{0,1,\bot\}$37, the concretization set is

$\{0,1,\bot\}$38

and the image-resolution set of a TM $\{0,1,\bot\}$39 is

$\{0,1,\bot\}$40

The coordinatewise superposition semantics $\{0,1,\bot\}$41 collapses this set into $\{0,1,\bot\}$42. The paper proves that the general metastable closure map $\{0,1,\bot\}$43 is not computable. Under bounded-time simulation, however, finer complexity results emerge: resolving a single uncertain bit for EXPTIME problems is EXPTIME-complete; for polynomial-time machines, the closure is computable in $\{0,1,\bot\}$44 time when the number of uncertain bits is $\{0,1,\bot\}$45; and the all-resolutions-agree problem is coNP-complete when the number of undefined bits is arbitrary. The paper also gives a hardware-realizable universal “Natural TM” that computes metastable closure of any bounded-time TM in $\{0,1,\bot\}$46 time and $\{0,1,\bot\}$47 space (Bund et al., 19 Apr 2026).

7. Hardware, complexity frontiers, and open directions

Hardware work on Tsetlin Machines increasingly treats inference as an architectural problem rather than only an algorithmic one. One recent design replaces arithmetic class-score summation by delay accumulation and replaces magnitude comparators by Winner-Takes-All arbitration in the time domain. For multi-class TMs, the reported figures are $\{0,1,\bot\}$48 GOp/s and $\{0,1,\bot\}$49 TOp/J for the proposed time-domain design, compared with $\{0,1,\bot\}$50 GOp/s and $\{0,1,\bot\}$51 TOp/J for the synchronous digital baseline and $\{0,1,\bot\}$52 GOp/s and $\{0,1,\bot\}$53 TOp/J for the asynchronous digital baseline. For CoTM, the hybrid digital-time-domain design reports $\{0,1,\bot\}$54 GOp/s and $\{0,1,\bot\}$55 TOp/J, versus $\{0,1,\bot\}$56 GOp/s and $\{0,1,\bot\}$57 TOp/J for the synchronous digital baseline. The verification case uses the Iris dataset with $\{0,1,\bot\}$58 features, $\{0,1,\bot\}$59 clauses, and $\{0,1,\bot\}$60 classes, and the paper states that all implementations produce identical predictions (Lan et al., 12 Nov 2025).

Several complexity frontiers remain explicit across these TM literatures. Relational Tsetlin Machines still assume simple sentences with one relation per sentence and restrict the learned program to non-recursive Horn clauses. Transition Machines for Det-POMDPs assume deterministic transitions, reliable labels, and structure-complete samples for minimality guarantees. Metastability-containing Turing Machines mark a hard undecidability boundary in the unrestricted case and sharp EXPTIME and coNP thresholds under time bounds. Recommendation-system Tsetlin Machines face time and memory bottlenecks at large catalog sizes. TMComposites identify better per-expert weighting, larger libraries of specialists, and collaboration-aware fine-tuning as open questions (Saha et al., 2021, Wu et al., 3 Aug 2025, Bund et al., 19 Apr 2026, Borgersen et al., 2022, Granmo, 2023).

Taken together, these strands show that “Transition Machines” is not a single theory but a family resemblance across automata-centered models. In one branch, finite-state automata learn interpretable logic and support relational reasoning, clause sharing, specialization, and event-driven hardware inference. In another, automata restore Markovian structure in partially observable control by making hidden transition history explicit. In a third, Turing-style machines are recast as executors of labelled transition systems or as devices computing closure under uncertainty. The common motif is not a shared formal definition, but the use of explicit machine state to make otherwise hidden structure computationally available.