Graph Tsetlin Machine

• GraphTM is a graph-aware extension of the Tsetlin Machine that applies propositional clause learning to node, edge, and subgraph patterns.
• It leverages deep clause decomposition and symbolic message passing with hypervector encodings to capture complex graph relationships.
• Empirical results show GraphTM achieves competitive accuracy across tasks like image, sentiment, and viral genome classification while ensuring interpretability.

Searching arXiv for the cited TM and GraphTM papers to ground the article. Graph Tsetlin Machine (GraphTM) denotes a family of Tsetlin Machine extensions that lift logical learning from flat Boolean vectors to graph-structured input while preserving the central TM mechanism: teams of Tsetlin automata learn explicit propositional formulas, organized as clauses, and classification is obtained by clause voting rather than gradient-based optimization. In the original TM, input, patterns, and outputs are expressed as bits, recognition and learning rely on bit manipulation, and the learning process is cast as a Tsetlin automata game whose Nash equilibria align with propositional formulas that provide optimal pattern recognition accuracy (Granmo, 2018). GraphTM reinterprets this foundation for nodes, edges, neighborhoods, subgraphs, and graph-level structure, with recent formulations using message passing, deep clauses, sparse hypervectors, and graph encodings that support sequences, grids, relations, multimodality, and variable-topology graphs (Granmo et al., 20 Jul 2025, Blakely, 22 Jul 2025).

1. Origins in the Tsetlin Machine formalism

The point of departure is the Tsetlin Machine (TM), a pattern recognition model that learns explicit propositional formulas composed of conjunctions of literals. For a single-output binary classification task, the input is

$X=(x_1,\dots,x_o)\in\{0,1\}^o,$

and the literal set is

$$L = \{l_1, \dots, l_{2o}\} = \{x_1, \dots, x_o,\ \bar{x}_1,\dots,\bar{x}_o\},\quad \bar{x}_k = 1 - x_k.$$

A clause $C_j$ is a conjunctive pattern,

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

where $L_j \subseteq L$ is the subset of literals included in clause $j$. Clauses are organized into positive and negative polarity, and the classifier is a majority vote of clause outputs: $$\hat{y} = u\!\left(\sum_{j=1}^{n/2} C^1_j(X) - \sum_{j=1}^{n/2} C^0_j(X)\right),$$ where $u(v)=1$ if $v\ge 0$ and $0$ otherwise (Granmo, 2018).

This architecture is discrete and combinatorial. Representation uses propositional logic over binary input features rather than continuous weights; learning uses teams of Tsetlin Automata rather than gradient descent; and the learned clauses are directly inspectable as logic rules. The original paper further states that the combination of high accuracy, interpretability, and computational simplicity makes the Tsetlin Machine a promising tool for a wide range of domains (Granmo, 2018).

GraphTM inherits this clause-centric view, but the semantics of a literal change. Instead of a flat literal such as $$L = \{l_1, \dots, l_{2o}\} = \{x_1, \dots, x_o,\ \bar{x}_1,\dots,\bar{x}_o\},\quad \bar{x}_k = 1 - x_k.$$0 or $$L = \{l_1, \dots, l_{2o}\} = \{x_1, \dots, x_o,\ \bar{x}_1,\dots,\bar{x}_o\},\quad \bar{x}_k = 1 - x_k.$$1, a graph literal can refer to node properties, edge types, neighborhood configurations, messages received from adjacent nodes, or graph-level symbolic encodings. This suggests that GraphTM is best understood not as a departure from TM, but as a graph-aware reinterpretation of the same propositional and bandit-driven learning machinery.

2. From flat Boolean vectors to graph-structured input

A first defining feature of GraphTM is that input is no longer assumed to be a fixed-length Boolean feature vector. One formulation operates directly on labeled directed multigraphs,

$$L = \{l_1, \dots, l_{2o}\} = \{x_1, \dots, x_o,\ \bar{x}_1,\dots,\bar{x}_o\},\quad \bar{x}_k = 1 - x_k.$$2

where $$L = \{l_1, \dots, l_{2o}\} = \{x_1, \dots, x_o,\ \bar{x}_1,\dots,\bar{x}_o\},\quad \bar{x}_k = 1 - x_k.$$3 is the set of nodes $$L = \{l_1, \dots, l_{2o}\} = \{x_1, \dots, x_o,\ \bar{x}_1,\dots,\bar{x}_o\},\quad \bar{x}_k = 1 - x_k.$$4, $$L = \{l_1, \dots, l_{2o}\} = \{x_1, \dots, x_o,\ \bar{x}_1,\dots,\bar{x}_o\},\quad \bar{x}_k = 1 - x_k.$$5 is the set of typed edges $$L = \{l_1, \dots, l_{2o}\} = \{x_1, \dots, x_o,\ \bar{x}_1,\dots,\bar{x}_o\},\quad \bar{x}_k = 1 - x_k.$$6, $$L = \{l_1, \dots, l_{2o}\} = \{x_1, \dots, x_o,\ \bar{x}_1,\dots,\bar{x}_o\},\quad \bar{x}_k = 1 - x_k.$$7 is the set of possible node properties, $$L = \{l_1, \dots, l_{2o}\} = \{x_1, \dots, x_o,\ \bar{x}_1,\dots,\bar{x}_o\},\quad \bar{x}_k = 1 - x_k.$$8 is the set of properties of node $$L = \{l_1, \dots, l_{2o}\} = \{x_1, \dots, x_o,\ \bar{x}_1,\dots,\bar{x}_o\},\quad \bar{x}_k = 1 - x_k.$$9, and $C_j$0 is an edge type (Granmo et al., 20 Jul 2025). In this setting, GraphTM is described as a Tsetlin Machine that operates on labeled directed multigraphs, uses message passing between graph nodes, and constructs deep clauses—clauses decomposed across graph layers—so that it can recognize subgraph patterns with far fewer clauses and retain interpretability (Granmo et al., 20 Jul 2025).

The graph representation is intentionally broad. The same framework is used to encode disconnected image patches, connected superpixel graphs, text with words as nodes and signed word-distance edge types, action-coreference state graphs, recommendation graphs with customers, products, and categories, and viral genome sequences encoded via $C_j$1-mers (Granmo et al., 20 Jul 2025). The paper explicitly states that moving beyond flat, fixed-length input makes GraphTM more versatile, supporting sequences, grids, relations, and multimodality (Granmo et al., 20 Jul 2025).

A second formulation targets variable-topology graph classification by first compiling each graph into a fixed-dimensional sparse binary hypervector and then applying a Coalesced multi-output Tsetlin Machine (CoTM) (Blakely, 22 Jul 2025). In that architecture, each graph is encoded through structured message passing, where node, edge, and attribute information are bound and bundled into a symbolic hypervector, and the resulting graph hypervector $C_j$2 is treated as the TM input (Blakely, 22 Jul 2025). The paper characterizes this as a Graph Tsetlin Machine for variable-topology graphs: instead of directly defining TM clauses over the relational structure, the method compiles graph structure into a symbolic hypervector space and then applies a TM (Blakely, 22 Jul 2025).

These two formulations differ in implementation strategy, but they share a common principle. Graph structure is rendered as Boolean or sparse binary symbolic structure that remains compatible with TA-controlled clause learning. A plausible implication is that GraphTM is less a single architecture than a design space constrained by TM logic, local TA updates, and discrete clause semantics.

3. Clause construction, deep clauses, and message passing

In the original TM, for each clause $C_j$3, one uses a team of $C_j$4 Tsetlin Automata, one per literal $C_j$5. Each automaton chooses between excluding and including its literal, so the clause is the conjunction of all included literals (Granmo, 2018). GraphTM preserves this principle but distributes clause semantics across graph layers.

In the graph-native formulation, each clause is factored into depth-wise components,

$C_j$6

Here, $C_j$7 operates on node properties via node hypervectors $C_j$8, while $C_j$9 operate on message hypervectors $$C_j(X) = \bigwedge_{l_k \in L_j} l_k = \prod_{l_k \in L_j} l_k,$$0, expressing conditions about messages received from neighbors (Granmo et al., 20 Jul 2025). These are termed deep clauses. Layer-wise clause-node matching is defined as

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

and for higher layers,

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

The clause output on the graph is then the OR over nodes,

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

This $$C_j(X) = \bigwedge_{l_k \in L_j} l_k = \prod_{l_k \in L_j} l_k,$$4 is the clause output used in voting (Granmo et al., 20 Jul 2025).

Message passing is central. When $$C_j(X) = \bigwedge_{l_k \in L_j} l_k = \prod_{l_k \in L_j} l_k,$$5 is true at node $$C_j(X) = \bigwedge_{l_k \in L_j} l_k = \prod_{l_k \in L_j} l_k,$$6, a message symbol $$C_j(X) = \bigwedge_{l_k \in L_j} l_k = \prod_{l_k \in L_j} l_k,$$7 is sent along edges; messages can be bound with edge-type symbols using a binding operator $$C_j(X) = \bigwedge_{l_k \in L_j} l_k = \prod_{l_k \in L_j} l_k,$$8, for example $$C_j(X) = \bigwedge_{l_k \in L_j} l_k = \prod_{l_k \in L_j} l_k,$$9, while bundling $L_j \subseteq L$0 combines multiple properties or messages into a single hypervector (Granmo et al., 20 Jul 2025). The resulting mechanism resembles multi-hop neighborhood aggregation, but the representation remains symbolic and Boolean rather than differentiable and real-valued.

The variable-topology symbolic framework adopts a different graph compiler. A sparse hypervector

$L_j \subseteq L$1

is used as the basic representation. Binding is defined by XOR,

$L_j \subseteq L$2

and bundling is defined by top-$L_j \subseteq L$3 selection after bitwise counting across multiple hypervectors (Blakely, 22 Jul 2025). Node representations are built as

$L_j \subseteq L$4

and edge messages are formed as

$L_j \subseteq L$5

The graph-level representation is then

$L_j \subseteq L$6

This is described as a two-layer hypervector message-passing scheme, with a three-layer extension also outlined (Blakely, 22 Jul 2025).

The conceptual distinction is therefore clear. One GraphTM variant keeps graph locality explicit inside clause evaluation through layered node-wise message passing; another compresses each graph into a symbolic hypervector and lets a standard CoTM operate on that encoding. Both preserve clause learning over binary structure and both treat graph relations as symbolic, not numeric.

4. Learning dynamics, bandit control, and theoretical grounding

The TM learning mechanism is built from two-action Tsetlin Automata. A Tsetlin Automaton is a finite-state machine with states $L_j \subseteq L$7, actions $L_j \subseteq L$8, and reward or penalty feedback that increments or decrements a single integer state index (Granmo, 2018). In the TM, the two actions correspond to excluding or including a literal in a clause. The paper states a convergence condition: a two-action Tsetlin Automaton converges to performing action $L_j \subseteq L$9 with probability arbitrarily close to $j$0 iff $j$1 and $j$2 (Granmo, 2018).

The original TM casts learning as a Tsetlin automata game. Players are the automata controlling literals; actions are include versus exclude; payoff depends on whether the clause is updated and on reward, inaction, or penalty from Type I or Type II feedback tables (Granmo, 2018). The central theoretical result is that, under the problem definition in the paper, the Nash equilibria of this game correspond exactly to propositional formulas that optimally capture underlying sub-patterns and thus maximize classification accuracy. The paper further states that, under certain constraints, the game is a generalized ordinal potential game (Granmo, 2018).

GraphTM inherits this TA-based learning logic. In the graph-native architecture, GraphTM reuses the standard TM machinery but applies it to hypervector bits representing properties and messages, and to deep clauses that span layers (Granmo et al., 20 Jul 2025). Once the graph-level clause outputs $j$3 are known, the model uses Coalesced CTM learning: multiple classes share clauses; each clause has a vector of class weights; for each training sample, per-clause outputs are computed, per-class aggregated votes are formed, and Type I or Type II feedback is applied to the clause automata using the same probability formulas and tables as in the standard TM (Granmo et al., 20 Jul 2025). The paper is explicit that the only structural change from TM to GraphTM is how clause outputs $j$4 are computed, via deep, graph-aware message passing (Granmo et al., 20 Jul 2025).

The standard TM feedback probabilities remain central. For positive clauses and $j$5,

$j$6

and for negative clauses and $j$7,

$j$8

with mirrored formulas by class and clause polarity (Granmo et al., 20 Jul 2025). In the original exposition, Type I feedback combats false negatives and grows clauses, while Type II feedback combats false positives and adds discriminating literals (Granmo, 2018). The resource-allocation role of the target parameter $j$9 also carries over: as the clause sum approaches $$\hat{y} = u\!\left(\sum_{j=1}^{n/2} C^1_j(X) - \sum_{j=1}^{n/2} C^0_j(X)\right),$$0, feedback diminishes, allowing other clauses to learn other sub-patterns (Granmo, 2018).

A common misconception is that GraphTM replaces TM theory with an unrelated graph heuristic. The published descriptions do not support that view. The graph-specific innovations concern representation, message routing, and clause composition, whereas the include-versus-exclude automaton logic, local reward and penalty updates, clause voting, and TM-style feedback remain intact (Granmo, 2018, Granmo et al., 20 Jul 2025).

5. Empirical scope and benchmark behavior

Recent GraphTM work evaluates the model across image classification, sentiment analysis, action coreference, recommendation systems, multivalue XOR, and viral genome sequence classification, while the symbolic hypervector variant evaluates on TUDataset graph classification benchmarks (Granmo et al., 20 Jul 2025, Blakely, 22 Jul 2025). The published results emphasize that GraphTM is not limited to a single graph regime: it can act on disconnected nodes, connected local neighborhoods, or compiled graph-level hypervectors.

The following reported results summarize representative findings already stated in the literature.

Task	Reported result	Source
CIFAR-10	GraphTM preserves interpretability and achieves 3.86%-points higher accuracy on CIFAR-10 than a convolutional TM	(Granmo et al., 20 Jul 2025)
Action coreference	Faced with increasingly challenging tasks, GraphTM outperforms other reinforcement learning methods by up to 20.6%-points	(Granmo et al., 20 Jul 2025)
Recommendation noise ratio 0.1	GraphTM obtains accuracy 89.86% compared to GCN's 70.87%	(Granmo et al., 20 Jul 2025)
Viral genome sequences	GraphTM is competitive with BiLSTM-CNN and GCN accuracy-wise, training 2.5x faster than GCN	(Granmo et al., 20 Jul 2025)
TUDataset graph classification	Competitive accuracy with strong symbolic transparency compared to neural graph models	(Blakely, 22 Jul 2025)

On disconnected-node image graphs, GraphTM is reported as $$\hat{y} = u\!\left(\sum_{j=1}^{n/2} C^1_j(X) - \sum_{j=1}^{n/2} C^0_j(X)\right),$$1 on MNIST, $$\hat{y} = u\!\left(\sum_{j=1}^{n/2} C^1_j(X) - \sum_{j=1}^{n/2} C^0_j(X)\right),$$2 on F-MNIST, and $$\hat{y} = u\!\left(\sum_{j=1}^{n/2} C^1_j(X) - \sum_{j=1}^{n/2} C^0_j(X)\right),$$3 on CIFAR-10, while the corresponding CoTM results are $$\hat{y} = u\!\left(\sum_{j=1}^{n/2} C^1_j(X) - \sum_{j=1}^{n/2} C^0_j(X)\right),$$4, $$\hat{y} = u\!\left(\sum_{j=1}^{n/2} C^1_j(X) - \sum_{j=1}^{n/2} C^0_j(X)\right),$$5, and $$\hat{y} = u\!\left(\sum_{j=1}^{n/2} C^1_j(X) - \sum_{j=1}^{n/2} C^0_j(X)\right),$$6 (Granmo et al., 20 Jul 2025). The interpretation given for CIFAR-10 is that GraphTM’s advantage arises from encoding multiple views in a single graph, whereas CoTM sees only a single view (Granmo et al., 20 Jul 2025).

On connected superpixel graphs for MNIST, the reported numbers are $$\hat{y} = u\!\left(\sum_{j=1}^{n/2} C^1_j(X) - \sum_{j=1}^{n/2} C^0_j(X)\right),$$7 for GraphTM with 20k clauses, $$\hat{y} = u\!\left(\sum_{j=1}^{n/2} C^1_j(X) - \sum_{j=1}^{n/2} C^0_j(X)\right),$$8 for GraphTM with 60k clauses, 75.62% for ChebNet, and 91.11% for MoNet (Granmo et al., 20 Jul 2025). For sentiment polarity classification, depth $$\hat{y} = u\!\left(\sum_{j=1}^{n/2} C^1_j(X) - \sum_{j=1}^{n/2} C^0_j(X)\right),$$9 GraphTM is consistently reported as better than depth $u(v)=1$0, with IMDB at $u(v)=1$1 versus $u(v)=1$2, Yelp at $u(v)=1$3 versus $u(v)=1$4, and MPQA at $u(v)=1$5 versus $u(v)=1$6 (Granmo et al., 20 Jul 2025). The paper interprets this as evidence that deep clauses help capture context via graph edges (Granmo et al., 20 Jul 2025).

For tracking action coreference, the reported 3-utterance results are GraphTM $u(v)=1$7, REINFORCE 68.5%, BS-MML 62.6%, and RANDOMER 65.8%; the 5-utterance results are GraphTM $u(v)=1$8, REINFORCE 37.3%, BS-MML 32.2%, and RANDOMER 37.1% (Granmo et al., 20 Jul 2025). For recommendation systems with injected noise, the reported accuracies at noise 0.005 are GCN 99.07, GraphTM 98.63, TM 76.64; at noise 0.1, GCN 70.87, GraphTM 89.86, TM 49.35; and at noise 0.2, GCN 66.23, GraphTM 78.17, TM 20.12 (Granmo et al., 20 Jul 2025).

For viral genome sequence classification into five virus classes, GraphTM depth $u(v)=1$9 is reported at 59.81% test accuracy and 62.47 s, GraphTM depth $v\ge 0$0 at 95.14% and 84.37 s, BiLSTM at 92.69% and 50.39 s, GRU at 94.05% and 25.47 s, BiLSTM-CNN at 95.44% and 32.65 s, and GCN at 96.35% and 226.36 s (Granmo et al., 20 Jul 2025). The paper states that GraphTM depth $v\ge 0$1 is competitive with BiLSTM-CNN and GCN, but faster than GCN (Granmo et al., 20 Jul 2025).

The symbolic graph-intelligence variant reports, for example, $v\ge 0$2 on DHFR_MD, $v\ge 0$3 on ER_MD, $v\ge 0$4 on PROTEINS, and $v\ge 0$5 on MUTAG, while also reporting weaker performance on NCI1 at $v\ge 0$6 (Blakely, 22 Jul 2025). The paper states that the method is particularly strong when rich attributes exist, such as DHFR_MD, ER_MD, and PROTEINS, and that poor performance on NCI1 indicates difficulty when only discrete labels and no numeric attributes are available (Blakely, 22 Jul 2025).

6. Interpretability, misconceptions, and limitations

Interpretability is a defining property across TM and GraphTM variants. Because clauses are explicit conjunctions of literals, the original TM can express patterns such as XOR in disjunctive normal form, for example $v\ge 0$7 and $v\ge 0$8 as positive clauses with corresponding negative clauses for the other assignments (Granmo, 2018). The original work also gives an image example where a clause for digit “1” yields a 2D bit pattern with “don’t care” positions, corresponding to a human-comprehensible stroke template (Granmo, 2018).

GraphTM extends this form of interpretability to subgraph patterns. In the graph-native model, node-layer clauses $v\ge 0$9 are Boolean expressions of symbolic properties, and message-layer clauses $0$0 are expressions over messages indexed by layer, clause, and edge direction or type (Granmo et al., 20 Jul 2025). The paper states that these message-layer clauses can always be “unrolled” by tracing messages back to layer $0$1, yielding a human-readable pattern over subgraphs (Granmo et al., 20 Jul 2025). Examples include sequence clauses such as

$0$2

which reads as “position $0$3 and next two positions are A” (Granmo et al., 20 Jul 2025).

The symbolic hypervector formulation proposes a local interpretability framework. It identifies which clauses contributed to a predicted class, aggregates literal-level contributions into an explanation hypervector, and then compares that explanation vector with node-role hypervectors using Hamming distance in order to identify influential nodes (Blakely, 22 Jul 2025). In the toy example reported, Hamming distances of $0$4, $0$5, and $0$6 lead to node $0$7 being deemed the top contributor (Blakely, 22 Jul 2025). The paper characterizes this as local interpretability and symbolic transparency rather than post-hoc explanation (Blakely, 22 Jul 2025).

Several misconceptions require qualification. One is that GraphTM is merely a graph neural network with binary activations. The published descriptions emphasize the opposite: messages are symbolic bits or sparse hypervectors; updates are Boolean or hypervector operations; learning is reinforcement-like through Tsetlin automata; and there is no backpropagation (Granmo et al., 20 Jul 2025, Blakely, 22 Jul 2025). Another misconception is that GraphTM is a single settled architecture. The literature instead presents at least two related approaches: one that operates directly on labeled directed multigraphs with deep clauses and TM-defined message passing, and one that encodes variable-topology graphs into a single symbolic hypervector before applying a CoTM (Granmo et al., 20 Jul 2025, Blakely, 22 Jul 2025).

The limitations are equally explicit. In the graph-native formulation, hypervector sizes must be chosen large enough to keep collisions low, and performance can drop with very long sequences unless hyperparameters are scaled (Granmo et al., 20 Jul 2025). The multivalue XOR experiments specifically report a non-linear interplay between clause count and hypervector dimensionality, including the finding that using 2000 clauses with a fixed message size can reduce accuracy due to message bit collisions, whereas 1000 clauses perform better with the same message size (Granmo et al., 20 Jul 2025). In the symbolic variable-topology formulation, the authors note hyperparameter sensitivity, limited message-passing expressiveness, an accuracy gap on pure-label datasets such as NCI1, and the fact that current encoding bundles all edges into a single hypervector but does not explicitly identify or reuse subgraph motifs (Blakely, 22 Jul 2025).

Taken together, these limitations indicate that GraphTM’s strengths are tightly linked to encoding quality, hypervector dimensionality, clause budget, and task structure. This suggests that GraphTM should be regarded as a principled symbolic-logic alternative to neural graph learning rather than as a universal replacement for GNNs. Its distinctive contribution lies in combining graph-aware symbolic representation, TM clause learning, and direct interpretability within a single discrete learning framework (Granmo et al., 20 Jul 2025, Blakely, 22 Jul 2025).