Title: On Logic-based Self-Explainable Graph Neural Networks
Venue: NeurIPS 2025
Accepted: yes
Keywords: graph neural networks

explainable ai

self-explainable gnns

interpretability
Abstract: Graphs are complex, non-Euclidean structures that require specialized models, such as Graph Neural Networks (GNNs), Graph Transformers, or kernel-based approaches, to effectively capture their relational patterns. This inherent complexity makes explaining GNNs decisions particularly challenging. Most existing explainable AI (XAI) methods for GNNs focus on identifying influential nodes or extracting subgraphs that highlight relevant motifs. However, these approaches often fall short of clarifying how such elements contribute to the final prediction. To overcome this limitation, logic-based explanations aim to derive explicit logical rules that reflect the model's decision-making process. Current logic-based methods are limited to post-hoc analyzes and are predominantly applied to graph classification, leaving a significant gap in intrinsically explainable GNN architectures. In this paper, we explore the potential of integrating logic reasoning directly into graph learning. We introduce LogiX-GIN, a novel, self-explainable GNN architecture that incorporates logic layers to produce interpretable logical rules as part of the learning process. Unlike post-hoc methods, LogiX-GIN provides faithful, transparent, and inherently interpretable explanations aligned with the model's internal computations. We evaluate LogiX-GIN across several graph-based tasks and show that it achieves competitive predictive performance while delivering clear, logic-based insights into its decision-making process.

On Logic-based Self-Explainable Graph Neural Networks

Abstract

Graphs are complex, non-Euclidean structures that require specialized models, such as Graph Neural Networks (GNNs), Graph Transformers, or kernel-based approaches, to effectively capture their relational patterns. This inherent complexity makes explaining GNNs decisions particularly challenging. Most existing explainable AI (XAI) methods for GNNs focus on identifying influential nodes or extracting subgraphs that highlight relevant motifs. However, these approaches often fall short of clarifying how such elements contribute to the final prediction. To overcome this limitation, logic-based explanations aim to derive explicit logical rules that reflect the model's decision-making process. Current logic-based methods are limited to post-hoc analyzes and are predominantly applied to graph classification, leaving a significant gap in intrinsically explainable GNN architectures. In this paper, we explore the potential of integrating logic reasoning directly into graph learning. We introduce LogiX-GIN, a novel, self-explainable GNN architecture that incorporates logic layers to produce interpretable logical rules as part of the learning process. Unlike post-hoc methods, LogiX-GIN provides faithful, transparent, and inherently interpretable explanations aligned with the model's internal computations. We evaluate LogiX-GIN across several graph-based tasks and show that it achieves competitive predictive performance while delivering clear, logic-based insights into its decision-making process.

1 Introduction

Graph Neural Networks (GNNs) are powerful models for learning from graph-structured data, excelling in tasks like node classification and graph classification [25, 29]. However, their complex message-passing mechanisms make it difficult to interpret how individual graph components influence predictions, limiting their use in critical domains that require transparency.

Several Explainable AI (XAI) techniques have been proposed to address the opacity of GNNs, typically falling into post-hoc and ante-hoc approaches. Post-hoc methods aim to explain an already trained black-box GNN by identifying influential graph components (e.g., nodes, edges, or subgraphs) that contribute to a specific decision [31, 20, 15]. These methods include perturbation-based approaches, gradient-based attribution, and concept-based methods that aim to extract meaningful graph patterns. Although effective, they often lack fidelity to the internal reasoning of the model, as they hardly capture the internal process of the model and can generate inconsistent or misleading

explanations [24]. Ante-hoc, or self-explainable, models, on the other hand, integrate interpretability into the learning process. Self-explainable GNNs (SE-GNNs) aim to ensure that the learned representations are inherently interpretable, often by enforcing constraints on the structure of explanations or by explicitly modeling feature importance. However, existing SE-GNNs present some limitations: topology-based approaches [17, 8, 22, 36, 21] identify the most relevant subgraphs while providing little insight into the logical rules underlying how the model represents graphs and makes its decisions [18, 19]; symbolic approaches propose distillation of the models into simpler or more interpretable architectures such as decision trees; and other approaches restrict the focus on node features, without using information about substructures [5, 3].

To address these limitations, logic-based XAI methods provide an alternative approach by extracting human-interpretable logical rules that govern the model's decision-making process [26]. Unlike gradient-based or perturbation-based explanations, logic rules explicitly define how features interact to produce a given outcome. When applied to GNNs, these approaches aim to map high-dimensional feature spaces to Boolean expressions that describe the presence of specific subgraph motifs or node interactions [2, 1]. However, currently existing logic-based GNN explainers are exclusively post-hoc or based on distillation of the GNNs using decision trees [19].

Recent advances in logic-explained networks for tabular data provide potential directions. Logic Explained Networks (LENs) [6] and Transparent Explainable Logic Layers (TELL) [23] propose architectures convertible into logical rules. Particularly relevant is TELL's approach, where nonnegative weight constraints allow direct extraction of first-order logic rules from the model parameters. However, these architectures were designed specifically for tabular data and cannot handle the complex relational structure of graphs. To address the lack of self-explainable logic GNN, in this work, we design a novel architecture that is intrinsically convertible into logic rules.

The theoretical foundation for connecting GNNs with formal logic is established by Barceló et al. [4], who demonstrate that some GNN architectures can represent statements in graded modal logic (GML) [10]. GML extends standard modal logic with numerical constraints, allowing expressions like "at least 3 neighboring nodes satisfy property P ", a natural fit for graph-based reasoning. While Barceló et al. [4] prove that GNNs can express GML propositions, it does not address the reverse problem: architecting GNNs to explicitly yield interpretable GML rules.

Constraining GNNs to adhere to logic comes with different challenges. To implement our model, LogiX-GIN, we modify the GIN architecture [30], such that it is possible to extract explanations in the form of GML. The choice of the GIN layer is dictated by its aggregation scheme, which uses the sum over neighboring nodes. This aggregation allows us to respect the counting functionality of GML. However, in order to count over input nodes, we cannot use a simple threshold as is done in TELL. For this reason, we introduce a preprocessing function that binarizes the input features depending on learnable intervals. An additional challenge comes from the use of sigmoid activations directly on the weights, as proposed in TELL. These tend to hinder gradient flow in multi-layer settings. This limits the effective training of models with many layers, as early layers receive little to no gradient updates. For this reason, we propose to first train a black-box model, GIN, and use it to pretrain our LogiX-GIN model. This allows for pretraining each layer separately and therefore avoids problems such as vanishing gradients.

Overall, the main contributions of our work are as follows: we propose LogiX-GIN, the first graph neural network that integrates logical reasoning directly into its architecture; we introduce a novel preprocessing function for automatic binarization of input features using intervals; we propose the first implementation of multi layer logic-based neural architecture by applying a distillation-based pretraining strategy to address vanishing gradient issues; we conduct extensive experiments to assess the interpretability, predictive performance, and limitations of LogiX-GIN; we provide an open-source implementation of our proposed approach and the conducted experiments 1 .

The remainder of this work is structured as follows: we begin by surveying the current literature on XAI for GNNs, self-explainable models and logic-based XAI; subsequently, we detail the mathematical foundations needed to comprehend our approach; we then present LogiX-GIN; we follow with an experimental evaluation on several datasets; finally, we summarize our findings and suggest potential directions for future research.

2 Related Work

In this section, we present the related literature to our work. We start by introducing self-explainable models for GNNs, and we then continue focusing on approaches that deliver explanations in the form of logic. Finally, we focus on approaches aimed at delivering logic explanations for GNNs.

Self-Explainable GNNs. SE-GNNs are designed to generate intrinsic explanations during inference, removing the need for post-hoc interpretation methods. A central approach in this paradigm involves the use of prototypes, intended as representative training instances, to construct inherently interpretable models. Prototype-based SE-GNNs adapt prototypical mechanisms to the graph domain, where the output class is determined using the similarity between the input and prototypes [36, 22, 21]. Despite the interpretability of the case-based approach, these models rely on embedding similarity, which isn't guaranteed to actually reflect structural similarity. Other approaches leverage information bottleneck methods to identify maximally informative subgraphs, ensuring that the extracted explanations retain only the most relevant structural components. For example, GIB [32] and VGIB [33] utilize information-theoretic principles to compress node and edge representations while preserving predictive performance. Kernel-based approaches such as KerGNNs [13] take a different route by employing graph kernels to provide explanations through kernel activations, allowing for a structured decomposition of the learned representations.

Logic-based XAI. Logic-based explainability methods [9] aim to improve model interpretability by incorporating logical constraints or symbolic reasoning directly into the learning process. Traditional machine learning models, like decision trees and rule-based classifiers, inherently provide logical explanations by explicitly representing decision boundaries. Although these models are transparent, they typically struggle with complex, high-dimensional data and cannot be easily integrated into deep learning frameworks due to their non-differentiability, which prevents the use of gradient-based optimization. This limitation has led to the development of neural architectures that incorporate logical reasoning while remaining compatible with backpropagation. A prominent example is represented by LENs [6], a class of neural networks that can be interpreted through logical rules. LENs are built on binary inputs and employ strong regularization, allowing the construction of truth tables from which logical rules can be derived. However, due to the post-hoc truth table procedure, these rules may not always faithfully represent the model's true behavior [23]. To overcome this issue, Ragno et al. [23] introduce TELL. TELL is an architecture with positive-weight constraints that ensure direct and faithful translation into logical rules. Furthermore, TELL is capable of handling continuous input data through a preprocessing function that automatically learns thresholds over features.

Logic-based Explanations for GNNs. Among the first logic-based approaches for GNNs, GLGExplainer [2] proposes to extract logical rules over explanations generated by another post-hoc method, such as PGExplainer [15]. This is achieved through the application of LENs over concept activation vector that encode the presence of specific subgraphs. While innovative, this approach relies on the application of an instance-level post-hoc procedure and on LENs, that were demonstrated to not be properly faithful [23, 1]. With GraphTrail, Armgaan et al. [1] propose to overcome these issues by using computation trees to identify relevant subgraphs and avoiding the need of post-hoc methods. These approaches primarily aim to identify rules over subgraphs in order to gain insight into the model's behavior. Taking a different direction, Pluska et al. [19] propose distilling a symbolic model from a GNN using iterative decision trees. Despite this difference, their method is also post-hoc, as the rules are extracted from graph embeddings. Additionally, the final model is no longer a GNN and cannot be reused in other neural network settings, thus losing the advantages of neural representations.

Although we share with the aforementioned works the goal of incorporating logic-based reasoning, our approach differs from current literature in a key aspect: rather than extracting rules in a post-hoc fashion, we aim to directly design a GNN model that is self-interpretable by construction. For this reason, in our case, distillation is used solely as a means to pre-initialize the self-interpretable model, not as an end in itself.

3 Background

We now introduce the key concepts and notations underlying our approach, focusing on how each element supports our logic-based self-explainable GNN. We start by formalizing GNNs, the base model we build upon. We then show how architectural constraints can enable direct extraction of logic rules from neural layers, introducing the core ideas of TELL. Finally, we present the mathematical foundations of GML, the formal system we use to express the logic rules produced by our model.

Graph Neural Networks. GNNs are neural networks designed for graph-structured data. They generally operate via message passing, where at each layer k a node v aggregates messages from its neighbors and updates its representation. Formally, this process can be written as:

Here, h ( k ) v denotes the updated representation of node v at layer k , using the ones at layer k -1 , h ( k -1) v . In the first layer, h ( k -1) v directly correspond to node features. The message function µ ( k ) aggregates information from the neighborhood, and the update function ϕ ( k ) combines it with the node's current state. Since nodes in a graph have no inherent ordering, the aggregation function must be permutation-invariant.

We use GIN [30] model, where the aggregation function is the sum, and the update function is a multi-layer perceptron (MLP) as this combination has been theoretically shown to achieve maximum discriminative power among message-passing GNNs. The sum aggregation can distinguish between different neighborhood structures and the MLP update function provides the necessary expressive capacity to obtain meaningful representations, enabling GIN to approximate the 1-WL (WeisfeilerLehman) graph isomorphism test, which is a strong baseline for distinguishing non-isomorphic graphs. In this architecture, each layer computes:

with ϵ ( k ) a learnable parameter. Multiple layers are stacked to capture increasingly abstract features. For node-level tasks, the resulting node embeddings are directly used. For graph-level tasks, a readout function (e.g., sum, mean, or max) aggregates node embeddings into a global representation for classification.

Transparent Explainable Logic Layer. TELL is a neural component designed to be interpretable through a direct conversion into first-order logic formulas. It constrains a standard linear layer, with I input neurons and O output ones, by enforcing non-negative weights and applying a threshold-based activation. Given an input X ∈ R I , it computes the output y = σ ( XW + + b ) ∈ R O . W + ∈ R I × O ≥ 0 is a weight matrix constrained to have only non-negative entries, b ∈ R O is a bias term, and σ is the sigmoid activation function.

A key feature of TELL is that it allows to be interpreted through logic rules. Considering the j-th binarized output y bin [ j ] = ✶ y [ j ] > 0 . 5 , it can then be associated with a rule in disjunctive normal form (DNF): y bin [ j ] = 1 ⇐⇒ ∑ i ∈ S W + [ i, j ] > -b [ j ] . S denotes the minimal subsets w.r.t set inclusion of the input sufficient to activate the neuron y [ j ] [23]. Following this, E j = ∨ S ∈S j ∧ i ∈ S x i can be defined as the logic rule for y [ j ] , where S j contains all the minimal subsets of inputs that satisfy the threshold -b [ j ] . This ensures a direct and interpretable mapping from network parameters to logical expressions. To extend TELL to handle continuous inputs, a preprocessing binarization step introduces an adaptive thresholding mechanism. This is done using ˜ X = σ ( X ⊙ exp( ˜ W ) + ˜ b ) , with ⊙ representing element-wise multiplication, and ˜ W ∈ R I and ˜ b ∈ R I being learnable parameters. Each transformed feature can then be interpreted as a binary predicate where ˜ x [ i ] = x [ i ] > -˜ b [ i ] .

exp( ˜

W

[

i

])

✶ These binary features can be incorporated into logical expressions, preserving TELL's explainability while enabling it to process real-valued data effectively.

Graded Modal Logic. GML is a fragment of first-order logic (FO) designed to express local properties of nodes in relational structures such as graphs, with support for counting. It restricts quantification to the immediate neighborhood of a node and ensures that formulas are evaluated locally, which makes it well-suited for graph-structured data.

Let us consider a first-order language that includes a symbol E ( x, y ) , for a binary relation between representing adjacency between nodes x and y of an undirected graph, and a finite collection of unary predicate symbols { P 1 ( x ) , . . . , P I ( x ) } of size I , which represent properties, features or types associated with individual nodes.

A graph structure G = ( V, E, { P i } i ∈ I ) consists of: a finite set of nodes V ; a symmetric edge relation E ⊆ V × V ; and, a collection of unary relations P i ⊆ V interpreting each predicate symbol.

Formulas of GML are a syntactic restriction of FO with exactly one free variable x . The set of formulas φ ( x ) is defined inductively by:

where N ∈ N > 0 , and ψ ( x ) , ψ 1 ( x ) , ψ 2 ( x ) , ψ 3 ( y ) are GML formulas.

Given a graph G and a node v , the relation G,v | = φ ( x ) that indicates that v ∈ G satisfies a generic GML formula φ ( x ) is defined as follows:

G,v | = P ( x ) : node v satisfies the atomic predicate P (i.e., v belongs to the unary predicate P ),

G,v | = ¬ ψ ( x ) : node v does not satisfy the formula ψ ( x ) (negation),

G,v | = ψ 1 ( x ) ∧ ψ 2 ( x ) : node v satisfies both subformulas ψ 1 ( x ) and ψ 2 ( x ) (logical conjunction),

G,v | = ψ 1 ( x ) ∨ ψ 2 ( x ) : node v satisfies at least one of the subformulas ψ 1 ( x ) or ψ 2 ( x ) (logical disjunction),

G,v | = ∃ ≥ N y ( E ( x, y ) ∧ ψ 3 ( y )) : node v has at least N neighbors u such that ( v, u ) ∈ E and each u satisfies ψ 3 ( y ) (quantified neighborhood condition).

A distinctive feature of GML is that all quantification is conditioned by the adjacency predicate E ( x, y ) . This ensures that the evaluation of any formula at a node v depends only on v and its neighborhood, not on the entire graph. Consequently, the logic is strictly less expressive than full FO, but computationally more tractable and naturally suited for expressing local patterns in graphs. For concrete examples of GML formulas, we refer the reader to Appendix B. The correspondence between GML and local properties of graphs plays a central role in recent work by Barceló et al. [4], where the authors show that it precisely characterizes the class of node properties computable by a certain class of graph neural networks.

4 LogiX-GIN

In this section, we formalize LogiX-GIN. We start by defining the different components of the architecture and then we present implementation and training details.

LogiX-GIN components. Like the original GIN architecture, LogiX-GIN performs aggregates embedding values through the sum, then a learnable parameterized function β binarizes the aggregated values in order to apply a logic transformation λ that is responsible to learn logic rules (as the one in TELL). The overall operation of the k -th LogiX-GIN layer can be formulated with the notation of Equation 1 as follows:

The first step involves aggregating the information of node v ∈ V and its neighbors by summing their features: a ( k ) v = ∑ u ∈N ( v ) ∪{ v } h ( k -1) u . This aggregation is equivalent to the one of GIN when setting ϵ = 0 , which is necessary to represent counting operations in GML. After summing binary

embeddings from neighboring nodes, the aggregated features become integer-valued. To apply logic-based rules, we binarize them using a novel thresholding mechanism. Specifically, we need a function capable to activate if its input falls within certain intervals. For this reason, we design a parametric Fourier step function, which flexibly and differentiably activates (outputs one) when counts fall within learnable value ranges:

where ⊙ denotes element-wise multiplication (Hadamard product), τ is a temperature hyperparameter (we use τ = 10 ), ˜ W ( k ) ∈ R d > 0 and ˜ b ( k ) ∈ R d > 0 are learnable parameters, and d the hidden dimension. β is a periodic step function with respect to a ( k ) v , where ˜ W ( k ) and ˜ b ( k ) modulate the width and the displacement of the counting intervals corresponding to an activation. Specifically, the intervals can be obtained as follows:

This enables the extraction of literals that are active only under precise counting conditions. To better clarify the functioning of β , we provide in Appendix A an example of the function varying the parameters ˜ W ( k ) and ˜ b ( k ) .

The final transformation λ ( k ) consists of the constrained linear transformation followed by a sigmoid activation function, as proposed in TELL:

Using the results of Ragno et al. [23], we use non-negative weights W +( k ) in order to constrain the model to be monotonic. This allows for retrieving logic rules in FO over the activations ˜ a ( k ) v , which correspond to formulas in GML over the literals h ( k -1) u of each node u ∈ V . Such logic rules are identified by the sets of weights of W +( k ) , which sum up to a value greater than -b ( k ) . For a more detailed and formal demonstration, the reader can refer to Appendix D.

LogiX-GIN overview. Here, we describe the practical implementation details of the LogiX-GIN architecture used in our experiments. The model is composed of five sequential LogiX-GIN layers, whose outputs are concatenated and passed through three global readout functions: sum, mean, and max. These aggregation functions extract global graph-level features by computing the total, average, and maximum activations of the rules learned by the five graph layers. The resulting features are then processed by a final TELL layer, which learns first-order logic rules over these activations to perform the prediction.

As previously discussed, the presence of sigmoid activation functions within each LogiX-GIN layer introduces significant challenges when training deep architectures. To address this, we adopt a knowledge distillation strategy for pretraining. Specifically, we initialize an auxiliary model with the same architecture, but replace the LogiX-GIN layers with standard GIN layers. To encourage binarized representations, this GIN model uses Gumbel-sigmoid activations. After training the GIN model, we use it as a teacher to guide the LogiX-GIN model for the first half of the training process: we minimize the cross-entropy loss between the hidden states of the GIN and LogiX-GIN models at each layer. This yields a layer-wise pretraining of the LogiX-GIN model. In the second half of training, we finetune the full LogiX-GIN model using standard supervised learning. Throughout the entire training procedure, optimization is carried out using gradient descent to minimize the cross-entropy loss combined with an L 1 regularization term on the weights W + .

Since there is no built-in constraint on the size of the learned logic rules, the resulting model can sometimes produce overly complex and less interpretable explanations. To enhance interpretability, we apply a post-training pruning procedure. This step consists of a final optimization stage in which each layer is trained individually in reverse order (from the last to the first) using an additional Hoyer regularization term: L Hoyer = ∥ W + ∥ 1 ∥ W + ∥ 2 + δ , where δ is a small constant to avoid division by zero. This regularization promotes sparsity in a structured way: unlike standard L 1 regularization, the Hoyer

loss encourages the use of a few large weights while pushing the remaining ones toward zero. Since the size of a logic rule is determined by how many weights need to be summed to reach the threshold -b , this sparsity directly reduces rule complexity. By applying this pruning procedure gradually and layer-wise, we minimize any potential impact on model performance while significantly improving the readability and compactness of the learned rules.

LogiX-GIN can provide explanations in different forms: logic rules can be extracted for each single layer to obtain a fine-grained set of rules that exactly reflect the model behavior; for a simpler overview, global logic rules can be obtained by identifying motifs that when present activate classspecific rules of the last layer; node attributions visualize node level contributions towards a prediction. Further details on the LogiX-GIN pipeline are detailed in Appendix C.

5 Experiments

In this section, we perform extensive experiments to evaluate our proposal. We begin by comparing the classification performances of LogiX-GIN with respect to its black-box counterpart. Successively, we perform an analysis of the interpretability of LogiX-GIN also in comparison with state-of-the-art approaches. We mainly focus on a logic-based analysis by identifying the global logic rules and layer-wise rules. For an additional analysis, we also report an experiment on node attributions in the Appendix E, comparing with other self-interpretable models and post-hoc approaches.

As the GIN layer, which inspires this work, is mainly developed for graph classification, we focus on this task for the experimental section. However, to offer a broader overview of the capabilities of LogiX-GIN, we also test the accuracy performances on some node classification datasets. For graph classification, the black-box GNNs are composed of 5 GIN layers, followed by a max, a sum and mean readouts. The readouts are concatenated and finally fed into an 2-layer MLP. We perform our experiments on the following 7 graph and 3 node classification datasets spanning synthetic graphs (BA2Motifs [15], BAMultiShapes [2], BAShapes, BACommunity and TreeGrid [31]), molecular graphs (MUTAG [11], Mutagenicity [14], NCI1 [28], and BBBP [16]), and protein graphs (PROTEINS [12]). We use grid-search to find the optimal hyperparameter combinations and report the test set results of the best performing hyperparameters on the validation set. Specifically, to ensure statistical validity, we report mean and standard deviation values over 10 different seeds.

In Table 1, we report the accuracy of the LogiX-GIN model compared to that of the black-box model across all datasets. In all cases, LogiX-GIN achieves accuracy levels within 3% of the black-box model, demonstrating strong performance despite the addition of logic constraints. These results indicate that incorporating logic constraints has a limited impact on predictive accuracy overall. While some trade-off in performance is expected, the primary goal of this work is to explore the integration of logic for enhanced model transparency. Table 2, instead, reports the accuracy scores of several SE-GNNs on graph classification. We observe that, compared to other self-interpretable approaches, our method reaches state-of-the-art performances on 5 datasets out of 7. In the remainder

LogiX-GIN

BA2Motifs

Mutagenicity

BAMultiShapes

N/A

Alignment: 0.737

Alignment: 1.000

MUTAG

Alignment: 0.895

V

Alignment: 1.000

P1

P2

P3

P4

P5

P1

∨

P2

∨

(P3

∧

¬P5)

∨

(P4

∧

¬P5)

V

Alignment: 1.000

Legend

Nitrogen

Carbon

Hydrogen

(not part of the pattern)

Alignment: 1.000

Alignment: 1.000

V

(H

∧

W)

∨

(H

∧

G)

∨

(W

∧

G)

H

W

G

of this section, we focus on the interpretability of LogiX-GIN, while in Appendix I, J and H, we detail hyperparameters settings and perform ablation studies.

Obtaining faithful global logic rules. Here, we compare the explanations produced by LogiX-GIN with those of GraphTrail [1]. As discussed in previous sections, despite sharing a logical foundation, the two methods differ substantially in their explanatory procedures: GraphTrail is a post-hoc method that generates rules over computation trees, whereas LogiX-GIN embeds logical reasoning directly into its architecture. LogiX-GIN, in fact, employs GML as its reasoning logic, which goes beyond simply detecting the presence of specific patterns via first-order logic. Despite these significant differences, if we narrow our focus to LogiX-GIN's final layer, the activations of the literals after the readout function can be interpreted as indicative patterns whose presence directly affects the final prediction. This observation forms the basis for our comparison between LogiX-GIN and GraphTrail.

For this experiment, we employ the four datasets used in the study by Armgaan et al. [1]. Due the 5layer architecture of the GIN blackbox, GraphTrail's SHAP-based computation becomes particularly resource-intensive. For this reason, on the BAMultiShapes dataset, GraphTrail fails to generate explanations within a feasible time frame (2 days). In Figure 1, we illustrate the patterns learned by both models. The LogiX-GIN patterns are extracted by analyzing the activations over the validation set. Full activation data is provided in Appendix F.

Notable differences emerge, especially on MUTAG and Mutagenicity. For MUTAG, GraphTrail identifies the NO 2 group, a well-known mutagenic substructure, while LogiX-GIN emphasizes carbon-based structures, especially aromatic atoms, which also play a key role in mutagenicity [1, 11]. However, we also anticipate that a deeper analysis reveals that LogiX-GIN does recognize

LogiX-GIN

Layer 1

13

12

14

11

10

9

15

16

7

8

1

2

3

6

5

4

20

17

19

18

Σ

∧

≤1

v'

∈𝓝

(v)

∪

{v}

Σ

=1

v'

∈𝓝

(v)

∪

{v}

0≤

∧

Σ

≤2

v'

∈𝓝

(v)

∪

{v}

1≤

True

Σ

=1

v'

∈𝓝

(v)

∪

{v}

Σ

∧

=0

v'

∈𝓝

(v)

∪

{v}

Σ

≤2

v'

∈𝓝

(v)

∪

{v}

1≤

∧

Σ

≤4

v'

∈𝓝

(v)

∪

{v}

3≤

LogiX-GIN

Layer 2

TELL

Σ

≤24

v

∈

V

8≤

Σ

=4

v'

∈𝓝

(v)

∪

{v}

∨

Σ

≤1

v'

∈𝓝

(v)

∪

{v}

0≤

¬

∧

(

)

¬

Nitrogen

Carbon

Σ

≥1

v'

∈𝓝

(v)

∪

{v}

Ego-Graph of node

v contains at least

1 node with the

feature     activated

Σ

≥9

v'

∈𝓝

(v)

∪

{v}

Graph contains

at least 9 nodes

with the feature

activated

Legend

Σ

v'

∈𝓝

(v)

∪

{v}

=2

Σ

v'

∈𝓝

(v)

∪

{v}

=1

Σ

v'

∈𝓝

(v)

∪

{v}

=1

17

6

19

18

the NO 2 group, although this occurs within its inner layers. This illustrates that our pattern-based analysis, when limited to the last layer, may offer only a partial view of the model's reasoning. On the Mutagenicity dataset, LogiX-GIN identifies simpler patterns such as successive nitrogen atoms and the NO 2 group. GraphTrail similarly detects these patterns in the black-box model, while also uncovering additional carbon-related structures. On BA2Motifs, both identify the house motif, while on BAMultiShapes, only LogiX-GIN recovers the ground-truth rule.

Overall, although both methods highlight chemically and structural meaningful patterns, Logix-GNN exhibits less complexity and higher versatility than GraphTrail. More importantly, the key difference lies in the 'alignment' between the model's behavior and the explanations. Alignment is defined as the accuracy between the model's predictions and the rule activations. GraphTrail, being post-hoc, may misalign with model behavior, while LogiX-GIN's explanations are fully aligned by design.

Explaining the single layers of LogiX-GIN. In this section, we analyze the core functionality of our approach, which enables inspection of the model at each individual layer. In Figure 2, we present a real-world example showing the actual rules learned by LogiX-GIN on the MUTAG dataset. This example provides insight into how the model learns to predict molecular mutagenicity through interpretable rule-based reasoning.

As a first observation, although the architecture consists of 5 convolutional layers, only 2 are actively used in the decision process. Notably, the first layer captures low-level features, such as atom type and connectivity, which are then leveraged to identify functional groups. The first rule (green), in fact, detects the NO 2 group by counting the number of nitrogens, oxygens, and carbons. Interestingly, to enhance specificity, the model also checks on the number of carbons to detect the NO 2 . The second rule (violet) is instead more complex, likely related to aromatic rings: the model counts the number of carbon atoms in each atom's neighborhood. Additionally, it also focuses on non-carbon atoms connected to only one carbon, which may help in identifying cyclic functional groups. The third feature (orange) activates across all nodes. While this might initially seem trivial, it serves an important role in the subsequent layer. In the second layer, in fact, features from the first layer are combined, and this feature is used for counting node connections. This offers valuable insight into the model's internal logic, showing how features that appear unrelated to the final prediction can still play a critical role.

Ultimately, the model's decision is determined by counting the number of nodes that activate a specific feature (pink) in the second convolutional layer. This mechanism sheds light on an important phenomenon: 'removing graph parts may not affect predictions if key activations stay within the learned range'. Consequently, even when a model appears to have lower fidelity w.r.t. node removal, this may be due not to reduced explainability, but to its reliance on counting-based decision logic.

Analyzing rules' complexity. We now analyze how the models use the layers to learn logic rules. With this aim, we analyze the models after the pruning procedure and study how layers learn rules. Figure 3 reports the amount of rules learned by each layer of the models. For each dataset, we select only one seed and one class and plot the number of rules extracted by each layer. In the cases of multiple classes, we use class 0 as the target. From this analysis, we exclude rules that provide no

Ba2Motifs

BaMultiShapes

MUTAG

Mutagenicity

PROTEINS

15

40

6

60

20

Rules

10

Rules

Rules

4

Rules

40

Rules

5

20

2

20

10

0

1

2

3

4

5

0

1

2

3

4

0

1

2

3

4

5

0

1

2

3

4

5

0

1

2

3

4

5

Layer

Layer

Layer

Layer

Layer

NCI1

BBBP

TreeGrid

BaCommunity

BaShapes

60

20

1.0

Rules

40

Rules

Rules

40

Rules

30

Rules

10

20

0.5

20

20

10

0

1

2

34

5

0

1

2

4

0

1

2

3

4

5

0

1

234

5

0.0

i

2

3

4

5

Layer

Layer

Layer

Layer

Layer

activations or activate on all the nodes, as they are mainly used to count node degrees. This analysis shows how models extract information from the graphs. Specifically, we observe that the first layers generally contain more rules, thus confirming the findings of the previous section. Indeed, the first layers tend to identify low-level patterns, which are then combined in the successive layers. We also see that in most cases the model does not use all the layers as the information extracted in the first layers is enough to perform the prediction. Contrarily, Mutagenicity and NCI1 are the datasets that require the highest amount of literals to describe the activity. This is most likely due to the higher complexity of the tasks and the high variability of the molecular graphs.

Overall, this analysis highlights the hierarchical nature of logic rules in the models. Early layers are densely populated with rules that extract fundamental features, while deeper layers serve a more selective role. This result is also confirmed when analysing rules activations (Appendix G). Furthermore, the redundancy of deeper layers in several datasets suggests a degree of architectural overcapacity, which pruning helps to address. Finally, the number of literals required across datasets underscores the varying complexity of the tasks and the richness of the input graphs, particularly in chemically diverse datasets. These interpretable insights directly inform model design: 'no rules after layer 2 imply excess layers can be removed'.

6 Conclusions

In this work, we introduced LogiX-GIN, a novel GNN architecture that incorporates logic-based reasoning directly into its layers to achieve self-explainability. We demonstrated that each layer of the architecture can be converted into logical formulas in GML formalism, offering a transparent and faithful representation of the model's reasoning. Through a series of experiments on both synthetic and real-world datasets for graph and node classification, we showed that LogiX-GIN maintains competitive performance while offering a new level of interpretability.

Despite these promising results, our work has some limitations. First, LogiX-GIN does not take into account edge features, limiting its potential expressiveness. Moreover, the usage of sigmoid activations and learnable binarization introduces training challenges, particularly in deeper networks or larger graphs. Although we mitigate these issues with a distillation-based pretraining strategy, the computational cost remains significant as the training is composed of multiple steps. Also, thresholding on input features might not be interpretable in cases where they are not attributed with specific semantic meanings. Future work could investigate case the integration with prototype-based or concept-based techniques that could improve interpretability thanks to their case-based reasoning. Another important limitation concerns the expressivity of the model itself: since LogiX-GIN relies on GML, its reasoning capabilities are constrained by what GML can express. As a result, the model may not be suitable for tasks that require more expressive or higher-order forms of reasoning beyond the scope of GML. Future research can address these limitations by exploring more scalable architectures and optimization techniques that preserve interpretability while improving computational efficiency. Additionally, extending the model to support a broader range of graph tasks or other logic formalisms might be interesting. In this case, combining logic-based reasoning with other forms of explanation, such as prototypes, may further enhance performance and interpretability.

Acknowledgments and Disclosure of Funding

This work was supported by French state aid managed by the National Research Agency under the France 2030 program, with the references 'WAIT4 ANR-22-PEAE-0008', 'PANDORA ANR-24CE23-0950", and "PORTRAIT ANR-22-CE23-0006".

References

Burouj Armgaan, Manthan Dalmia, Sourav Medya, and Sayan Ranu. Graphtrail: Translating gnn predictions into human-interpretable logical rules. In The Thirty-eighth Annual Conference on Neural Information Processing Systems , 2024.

Steve Azzolin, Antonio Longa, Pietro Barbiero, Pietro Lio, Andrea Passerini, et al. Global explainability of gnns via logic combination of learned concepts. In ICLR 2023 , pages 1-19. online, 2023.

Steve Azzolin, SAGAR MALHOTRA, Andrea Passerini, and Stefano Teso. Beyond topological self-explainable gnns: A formal explainability perspective. In Forty-second International Conference on Machine Learning , 2025.

Pablo Barceló, Egor V Kostylev, Mikael Monet, Jorge Pérez, Juan Reutter, and Juan-Pablo Silva. The logical expressiveness of graph neural networks. In 8th International Conference on Learning Representations (ICLR 2020) , 2020.

Maya Bechler-Speicher, Amir Globerson, and Ran Gilad-Bachrach. The intelligible and effective graph neural additive network. Advances in Neural Information Processing Systems , 37:90552-90578, 2024.

Gabriele Ciravegna, Pietro Barbiero, Francesco Giannini, Marco Gori, Pietro Lió, Marco Maggini, and Stefano Melacci. Logic explained networks. Artificial Intelligence , 314:103822, 2023.

Luigi Pietro Cordella, Pasquale Foggia, Carlo Sansone, Mario Vento, et al. An improved algorithm for matching large graphs. In IAPR-TC15 , 2001.

Enyan Dai and Suhang Wang. Towards prototype-based self-explainable graph neural network. ACM Transactions on Knowledge Discovery from Data , 2022.

Adnan Darwiche. Logic for explainable ai. In 2023 38th Annual ACM/IEEE Symposium on Logic in Computer Science (LICS) , pages 1-11. IEEE, 2023.

Maarten De Rijke. A note on graded modal logic. Studia Logica , 64(2):271-283, 2000.

Asim Kumar Debnath, Rosa L. Lopez de Compadre, Gargi Debnath, Alan J. Shusterman, and Corwin Hansch. Structure-activity relationship of mutagenic aromatic and heteroaromatic nitro compounds. correlation with molecular orbital energies and hydrophobicity. Journal of Medicinal Chemistry , 34(2):786-797, Feb 1991. ISSN 0022-2623.

Paul D. Dobson and Andrew J. Doig. Distinguishing enzyme structures from non-enzymes without alignments. Journal of Molecular Biology , 330(4):771-783, 2003. ISSN 0022-2836.

Aosong Feng, Chenyu You, Shiqiang Wang, and Leandros Tassiulas. Kergnns: Interpretable graph neural networks with graph kernels. Proceedings of the AAAI Conference on Artificial Intelligence , 36(6):6614-6622, Jun. 2022. doi: 10.1609/aaai.v36i6.20615. URL https: //ojs.aaai.org/index.php/AAAI/article/view/20615 .

Jeroen Kazius, Ross McGuire, and Roberta Bursi. Derivation and validation of toxicophores for mutagenicity prediction. Journal of Medicinal Chemistry , 48(1):312-320, December 2004. ISSN 1520-4804.

Dongsheng Luo, Wei Cheng, Dongkuan Xu, Wenchao Yu, Bo Zong, Haifeng Chen, and Xiang Zhang. Parameterized explainer for graph neural network. Advances in neural information processing systems , 33:19620-19631, 2020.

Ines Filipa Martins, Ana L. Teixeira, Luis Pinheiro, and Andre O. Falcao. A bayesian approach to in silico blood-brain barrier penetration modeling. Journal of Chemical Information and Modeling , 52(6):1686-1697, jun 2012.

Siqi Miao, Mia Liu, and Pan Li. Interpretable and generalizable graph learning via stochastic attention mechanism. In International Conference on Machine Learning , pages 15524-15543. PMLR, 2022.

Peter Müller, Lukas Faber, Karolis Martinkus, and Roger Wattenhofer. Graphchef: Learning the recipe of your dataset. In ICML 3rd Workshop on Interpretable Machine Learning in Healthcare (IMLH) , 2023.

Alexander Pluska, Pascal Welke, Thomas Gärtner, and SAGAR MALHOTRA. Logical distillation of graph neural networks. In ICML 2024 Workshop on Mechanistic Interpretability , 2024. URL https://openreview.net/forum?id=TfYnD2gYRO .

Phillip E Pope, Soheil Kolouri, Mohammad Rostami, Charles E Martin, and Heiko Hoffmann. Explainability methods for graph convolutional neural networks. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition , pages 10772-10781, 2019.

Alessio Ragno and Roberto Capobianco. Impo: Interpretable memory-based prototypical pooling. In Proceedings of the Eighteenth ACM International Conference on Web Search and Data Mining , WSDM '25, page 625-632, New York, NY, USA, 2025. Association for Computing Machinery. ISBN 9798400713293. doi: 10.1145/3701551.3703543. URL https: //doi.org/10.1145/3701551.3703543 .

Alessio Ragno, Biagio La Rosa, and Roberto Capobianco. Prototype-based interpretable graph neural networks. IEEE Transactions on Artificial Intelligence , 5(4):1486-1495, 2022.

Alessio Ragno, Marc Plantevit, Celine Robardet, Roberto Capobianco, et al. Transparent explainable logic layers. In ECAI 2024-27th European Conference on Artificial Intelligence, 19-24 October 2024, Santiago de Compostela, Spain-Including 13th Conference on Prestigious Applications of Intelligent Systems (PAIS 2024) , volume 392, pages 914-921. Ios Press, 2024.

Cynthia Rudin. Stop explaining black box machine learning models for high stakes decisions and use interpretable models instead. Nat. Mach. Intell. , 1(5):206-215, 2019. doi: 10.1038/ S42256-019-0048-X. URL https://doi.org/10.1038/s42256-019-0048-x .

Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE transactions on neural networks , 20(1):61-80, 2008.

Thomas Schnake, Farnoush Rezaei Jafari, Jonas Lederer, Ping Xiong, Shinichi Nakajima, Stefan Gugler, Grégoire Montavon, and Klaus-Robert Müller. Towards symbolic xai-explanation through human understandable logical relationships between features. Information Fusion , 118: 102923, 2025.

Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. In International conference on machine learning , pages 3319-3328. PMLR, 2017.

Nikil Wale, Ian A. Watson, and George Karypis. Comparison of descriptor spaces for chemical compound retrieval and classification. Knowledge and Information Systems , 14(3):347-375, August 2007.

Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and S Yu Philip. A comprehensive survey on graph neural networks. IEEE transactions on neural networks and learning systems , 32(1):4-24, 2020.

Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In International Conference on Learning Representations , 2019. URL https: //openreview.net/forum?id=ryGs6iA5Km .

Zhitao Ying, Dylan Bourgeois, Jiaxuan You, Marinka Zitnik, and Jure Leskovec. Gnnexplainer: Generating explanations for graph neural networks. Advances in neural information processing systems , 32, 2019.

Junchi Yu, Tingyang Xu, Yu Rong, Yatao Bian, Junzhou Huang, and Ran He. Graph information bottleneck for subgraph recognition. In International Conference on Learning Representations , 2021. URL https://openreview.net/forum?id=bM4Iqfg8M2k .

Junchi Yu, Jie Cao, and Ran He. Improving subgraph recognition with variational graph information bottleneck. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR) , pages 19396-19405, June 2022. URL https://openaccess. thecvf.com/content/CVPR2022/papers/Yu_Improving_Subgraph_Recognition_ With_Variational_Graph_Information_Bottleneck_CVPR_2022_paper.pdf .

Hao Yuan, Haiyang Yu, Jie Wang, Kang Li, and Shuiwang Ji. On explainability of graph neural networks via subgraph explorations. In International conference on machine learning , pages 12241-12252. PMLR, 2021.

Shichang Zhang, Yozen Liu, Neil Shah, and Yizhou Sun. Gstarx: Explaining graph neural networks with structure-aware cooperative games. Advances in Neural Information Processing Systems , 35:19810-19823, 2022.

Zaixi Zhang, Qi Liu, Hao Wang, Chengqiang Lu, and Cheekong Lee. Protgnn: Towards self-explaining graph neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence , volume 36, pages 9127-9135, 2022.

NeurIPS Paper Checklist

1. Claims

Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?

Answer: [Yes]

Justification: Our abstract and introduction clearly outline the contributions of the paper.

Guidelines:

The answer NA means that the abstract and introduction do not include the claims made in the paper.

The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers.

The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings.

It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper.

2. Limitations

Question: Does the paper discuss the limitations of the work performed by the authors?

Answer: [Yes]

Justification: The limitations are addressed in Section 6

Guidelines:

The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.

The authors are encouraged to create a separate "Limitations" section in their paper.

The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.

The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.

The authors should reflect on the factors that influence the performance of the approach. For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.

The authors shouldindeed if u look at the rule in discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.

If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.

While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.

3. Theory Assumptions and Proofs

Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?

Answer: [Yes]

Justification: We provide a proof of our theoretical result in Supplementary Section D Guidelines:

The answer NA means that the paper does not include theoretical results.

All the theorems, formulas, and proofs in the paper should be numbered and crossreferenced.

All assumptions should be clearly stated or referenced in the statement of any theorems.

The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch to provide intuition.

Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material.

Theorems and Lemmas that the proof relies upon should be properly referenced.

4. Experimental Result Reproducibility

Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?

Answer: [Yes]

Justification: We provide in the Supplementary Material the code and all the necessary information to reproduce our results.

Guidelines:

The answer NA means that the paper does not include experiments.

If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.

If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.

Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.

While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example

(a) If the contribution is primarily a new algorithm, the paper should make it clear how to reproduce that algorithm.

(b) If the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully.

(c) If the contribution is a new model (e.g., a large language model), then there should either be a way to access this model for reproducing the results or a way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset).

(d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.

5. Open access to data and code

Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material?

Answer: [Yes]

Justification: We do provide open access to the code. The data is already publicly available and we cited the proper sources.

Guidelines:

The answer NA means that paper does not include experiments requiring code.

Please see the NeurIPS code and data submission guidelines ( https://nips.cc/ public/guides/CodeSubmissionPolicy ) for more details.

While we encourage the release of code and data, we understand that this might not be possible, so 'No' is an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for a new open-source benchmark).

The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurIPS code and data submission guidelines ( https: //nips.cc/public/guides/CodeSubmissionPolicy ) for more details.

The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.

The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. If only a subset of experiments are reproducible, they should state which ones are omitted from the script and why.

At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).

Providing as much information as possible in supplemental material (appended to the paper) is recommended, but including URLs to data and code is permitted.

6. Experimental Setting/Details

Question: Does the paper specify all the training and test details (e.g., data splits, hyperparameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?

Answer: [Yes]

Justification: The Experimental Settings are detailed in Supplementary Section I and in the code.

Guidelines:

The answer NA means that the paper does not include experiments.

The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them.

The full details can be provided either with the code, in appendix, or as supplemental material.

7. Experiment Statistical Significance

Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?

Answer: [Yes]

Justification: We do replicate experiments on different seeds and report mean and standard deviation of the results for statistical significance.

Guidelines:

The answer NA means that the paper does not include experiments.

The authors should answer "Yes" if the results are accompanied by error bars, confidence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.

The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions).

The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)

The assumptions made should be given (e.g., Normally distributed errors).

It should be clear whether the error bar is the standard deviation or the standard error of the mean.

It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have a 96% CI, if the hypothesis of Normality of errors is not verified.

For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates).

If error bars are reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables in the text.

8. Experiments Compute Resources

Question: For each experiment, does the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?

Answer: [Yes]

Justification: We do report such information in the Supplementary Section I

Guidelines:

The answer NA means that the paper does not include experiments.

The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.

The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute.

The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make it into the paper).

9. Code Of Ethics

Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics https://neurips.cc/public/EthicsGuidelines ?

Answer: [Yes]

Justification: We follow the NeurIPS Code of Ethics.

Guidelines:

The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.

If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics.

The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or regulations in their jurisdiction).

10. Broader Impacts

Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?

Answer: [NA]

Justification: [NA]

Guidelines:

The answer NA means that there is no societal impact of the work performed.

If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.

Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.

The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.

The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.

If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML).

11. Safeguards

Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?

Answer: [NA]

Justification: [NA]

Guidelines:

The answer NA means that the paper poses no such risks.

Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters.

Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.

We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort.

12. Licenses for existing assets

Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?

Answer: [Yes]

Justification: All the datasets and techniques are cited in the references.

Guidelines:

The answer NA means that the paper does not use existing assets.

The authors should cite the original paper that produced the code package or dataset.

The authors should state which version of the asset is used and, if possible, include a URL.

The name of the license (e.g., CC-BY 4.0) should be included for each asset.

For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided.

If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswithcode.com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset.

For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided.

If this information is not available online, the authors are encouraged to reach out to the asset's creators.

13. New Assets

Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?

Answer: [Yes]

Justification: The background, proposal and experimental sections document the setting used. The code and the assets is also available as supplementary material.

Guidelines:

The answer NA means that the paper does not release new assets.

Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc.

The paper should discuss whether and how consent was obtained from people whose asset is used.

At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.

14. Crowdsourcing and Research with Human Subjects

Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?

Answer: [NA]

Justification: [NA]

Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.

Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper.

According to the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.

15. Institutional Review Board (IRB) Approvals or Equivalent for Research with Human Subjects

Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?

Answer: [NA]

Justification: [NA]

Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.

Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.

We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution.

For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review.

16. Declaration of LLM usage

Question: Does the paper describe the usage of LLMs if it is an important, original, or non-standard component of the core methods in this research? Note that if the LLM is used only for writing, editing, or formatting purposes and does not impact the core methodology, scientific rigorousness, or originality of the research, declaration is not required.

Answer: [NA]

Justification: [NA]

Guidelines:

The answer NA means that the core method development in this research does not involve LLMs as any important, original, or non-standard components.

Please refer to our LLM policy ( https://neurips.cc/Conferences/2025/LLM ) for what should or should not be described.

A Fourier Step Function

In this section, we analyze the functionality of the β function of LogiX-GIN as defined in Equation 5. Figure 4 shows three examples illustrating how the parameters w (width) and b (bias or displacement) affect the shape and position of the intervals. The first case ( w = 1 , b = 0 ) shows a baseline case where, in this interval of input values ( -5 < x < 5 ), the output corresponds to a 1 if x < -3 or 0 < x < 3 . The second case ( w = 2 , b = 0 ) highlights how w can be used to modify the width of the intervals. Finally, the third case ( w = 1 , b = -2 ) shows how the parameter b is instead responsible to apply a displacement of the thresholds (in this case of -2 ).

W = 1, b = 0

1.0 -

sss

SS

0.8

Binarized Value

0.6

0.4

0.2

0.0

-5

-4

-3

2

1

0

1

2

3

4

5

Input Value

W = 2, b = 0

1.0

80

Value

0.6

Binarized

0.4

0.2

W

W

0.0

-5

-4

-3

2

-1

0

1

2

3

4

5

Input Value

W = 1, b = -2

1.0

0.8

Value

0.6

Binarized

0.4

0.2

0.0

M

>>

>

-5

-4

-3

2

1

0

1

2

3

4

5

Input Value

B Examples of Graded Modal Logic Formulas

Following Barceló et al. [4], we use colors as unary predicates: Blue(x) , Red(x) , and Green(x) denote that node x is respectively blue, red, or green.

Example 1: Atomic predicate.

This formula holds if x is blue.

Example 2: At least two red neighbors.

This states that x has at least two neighbors that are red.

Example 3: Blue node without red neighbors.

This expresses that x is blue and has no red neighbors.

Example 4: Disjunction of neighborhood conditions.

This means that x has either at least three red neighbors, or at least one green neighbor.

Example 5: Nested neighborhood property.

This states that x has a neighbor y which itself has at least one green neighbor z .

These examples illustrate how GML formulas, written with colored predicates, capture local structural patterns in graphs using counting quantifiers and logical connectives.

C LogiX-GIN Explanation Procedure

v

1

1

1

1

1

1

1

1

1

1

0

0

v

4

3

3

3

2

1

3

2

1

4

4

3

2

1

4

v

1

1

0

y = σ(2x 1  + x 2  + x 3  - 2.5)

x 1

∧

( x 2

∨

x 3

)

Σ

∧

≥3

v'

∈𝓝

(v)

∪

{v}

Σ

≤4

v'

∈𝓝

(v)

∪

{v}

∨

Σ

≤2

v'

∈𝓝

(v)

∪

{v}

(1≤

)

Sum Aggregation

Overview and pipeline. Figure 5 shows the LogiX-GIN pipeline. Node features from a target node and its neighborhood are first aggregated by summation. These aggregated values are then binarized by a learnable Fourier step function, which converts counts into discrete on/off literals. The binarized signals are passed through a logic layer with non-negative weights, producing interpretable logical activations. During training, a teacher GIN model is used for distillation, and Hoyer-style pruning can be applied to remove redundant rules. From this pipeline, we can extract explanations at different levels of granularity:

Layer-by-layer explanations provide a fine-grained analysis representing the exact model behavior. Each hidden layer corresponds to a set of logic rules that are directly readable from the parameters of its logic transformation. For every output unit, the threshold conditions

on its binary inputs define minimal logical clauses. Presenting rules per layer allows us to reconstruct how evidence is accumulated step by step, without needing to collapse the entire network into a single formula.

Global logic rules identify logic formulas over subgraphs that globally approximate the model's behavior. To obtain them, at the final classifier, we extract global rules that summarize the decision process for the whole graph. The extraction procedure follows the following step:

Apply rule extraction to the final logic layer, obtaining global rules associated with each class.

Identify the nodes in a given graph that activate these rules.

Collect the induced neighborhoods of these nodes and compute canonical subgraphs.

Use a standard graph isomorphism algorithm [7] to merge isomorphic subgraphs and identify recurring motifs.

The resulting set of global rules provides human-readable summaries such as graphs containing motif M are classified as class c '. To evaluate these rules, we measure their alignment, that is, the agreement between the rule activations and the model's predictions on held-out data.

Node attributions from global rules provide scores for nodes of a graph which measure their contribution towards a prediction. When a global rule is activated for a graph, we can attribute responsibility to the specific nodes that support its conditions. A node is considered relevant if it appears in at least one minimal conjunct that satisfies the rule. In this way, the explanation highlights the exact part of the graph that triggered the decision. This yields node-level attributions that are directly derived from the logic rules, avoiding the need for post-hoc gradient or perturbation methods.

D Demonstration

Proposition 1. Let h ( k ) v denote the output of the k -th layer of the LogiX-GIN architecture, defined as in Equation 4, where λ ( k ) is a monotonic logic transformation as in Equation 7, and β ( k ) is a differentiable binarization function over learned activation intervals as in Equation 5. Then, for each k , there exists a set of formulas { φ ( k ) j ( x ) } j in the syntax of GML such that

where G is the input graph and x is the free variable corresponding to node v .

Proof. We proceed by structural correspondence between the computational components of h ( k ) v and the semantic constructs of GML:

Aggregation. Given a node v ∈ V , the expression

computes, for each feature index i ∈ { 1 , ..., d } , with d the hidden dimension, the number of neighbors u such that h ( k -1) u [ i ] = 1 . This results in a count vector a v ∈ N d , where each entry encodes the multiplicity of a property among the neighbors.

Binarization. The function β ( k ) applies learnable thresholding to each coordinate a v [ i ] , producing:

Each output ˜ a ( k ) v [ i ] = 1 encodes the satisfaction of a threshold condition:

where I β ( k ) ,i is a learnable interval determined by β ( k ) for the i -th dimension, as defined in Equation 6. By inductive hypothesis, for each i , there exists a formula ψ ( k -1) i ( x ) such that h ( k -1) u [ i ] = 1 ⇐⇒ ( G,u ) | = ψ ( k -1) i ( x ) . Therefore:

Hence, each a ( k ) v [ i ] corresponds to a valid graded modality in GML.

Monotonic Logic Layer. As shown by Ragno et al. [23], due to non-negativity of weights and the monotonicity of σ , each output neuron h ( k ) v [ j ] from Equation 7 corresponds to a logic formula in disjunctive normal form (DNF):

wher S j is the set of subsets of features with corresponding weights that sum up to a value greater than -b ( k ) j . Since each a ( k ) v [ i ] corresponds to a GML formula as shown above, it follows that:

where

By induction on k , and given that the base case (input binarization) is definable by unary predicates, we conclude that all h ( k ) v [ j ] are convertible into GML formulas. Thus, the output of the LogiX-GIN architecture is fully convertible in GML.

E Node Attribution Evaluation

Here, we perform an analysis to evaluate the explanations proposed by different approaches when simply focus on node attributions. We perform our comparison with 5 post-hoc methods (GNNExplainer [31], PGExplainer [15], Integrated Gradients [27], SubgraphX [34], and GStarX [35]) applied on the black-box GIN model and 2 self-interpretable models (PiGNN [22] and GIB [32]) We perform the evaluation in terms of the Fidelity of the attributions. Fidelity is defined as the ratio of graphs whose prediction is shifted when removing the most important nodes.

In literature, node attribution evaluation is mainly designed of post-hoc instance-level approaches, which focus on finding the most important nodes that lead to a specific prediction. On the contrary, selfinterpretable models are designed to provide visual explanations thanks to architectural constraints. For these reasons, node attributions represent only an approximation of the explanatory power of self-interpretable models and this evaluation setting can end up being unfair to them. This is primarily due to a lack of evaluation methods for self-interpretable models in literature for several reasons. First, these type of models are still highly unexplored, second, there is often a high diversity between the various approaches. For instance, prototype-based approaches use the similarity between prototypes and subgraphs of the input graph to determine the class. Node attributions for these methods are obtained by extracting such similarities. However, it is not guaranteed that removing the portions of the input graphs that actually led to a specific prediction cause a shift in the prediction. On the contrary, optimization-based methods such as GStarX that specifically aims to find subgraphs that when removed provoke shifts in the prediction. Additionally, while with post-hoc methods are generally compared when applied on the same model, in the case of self-explainable models, we have different models under analysis.

NCI1

Mutagenicity

MUTAG

0.8

0.4

0.6

Fidelity

Fidelity

0.6

Fidelity

0.3

0.4

0.4

0.2

0.2

0.2

0.5

0.6

0.7

0.8

0.9

0.5

0.6

0.7

0.8

0.9

0.5

0.6

0.7

0.8

0.9

Sparsity

Sparsity

Sparsity

BA2Motifs

BAMultiShapes

BBBP

0.6

0.5

0.5

0.6

0.4

Fidelity

0.4

Fidelity

0.5

Fidelity

0.3

0.3

0.4

0.2

0.3

0.2

0.1

0.2

0.1

0.5

0.6

0.7

0.8

0.9

0.5

0.6

0.7

0.8

0.9

0.5

0.6

0.7

0.8

0.9

Sparsity

Sparsity

Sparsity

PROTEINS

0.6

0.5

0.2

0.1

0.5

0.6

0.7

0.8

0.9

Sparsity

GNNExpl.

PGExpl.

IG

SubGraphx

GStarX

GIB

PiGNN

LogiX-GIN

Figure 6 shows the Fidelity score on the graph classification datasets. Since the different methods report continuous attribution score, the fidelity is calculated on the hard masks at different sparsity level. In particular, we vary the sparsity between 0.5 and 0.95.

We observe that on four cases, namely NCI1, MUTAG, BA2Motifs and BAMultiShapes, LogiX-GIN produces Fidelity scores that are comparable or better that the state-of-the-art post-hoc approaches, specifically with optimization-based ones. On BBBP, Mutagenicity and PROTEINS, instead we observe better values from GStarX and PiGNN. However, as already underlined, in the case of LogiX-GIN, explanations are obtained by simply looking at the rules activated on the last layer, which might not truly indicate its true behavior. For this reason, we believe that a more thorough examination of the model through inspection of its complete logic rules can actually provide better transparency of the model.

F Last Layer Rule Activations

This section reports the activations of the logic rules of the last layers on the datasets of the global rules experiment. Figure 7 shows graphs of the validation set highlighting the nodes that activate the rules of the last layer. In order to provide a compact representations, activations are aggregated using isomorphism. Therefore, for each dataset, only non-isomorphic activations are shown. We observe that the rules capture patterns that are generally known to be related with the predicted class.

(a) BA2Motifs

(b) MUTAG

(c) Mutagenicity

(d) BAMultiShapes

?

?

?

16

10

20

15

26

3

12

22

3

G Logic Rules Activations

This section reports the activations of the logic rules on the 10 datasets. For each model we extract the rules of each layer and we plot in Figure 8 the distribution on the percentage of the nodes that are

Layer 1

Layer 2

Layer3

Layer 4

Layer 5

2

1.0

1.0

Ba2Motifs

Rules

Ba2Motifs

Ba2Motifs

Rules

Ba2Motifs

Ba2Motifs

Rules

0.5

0.5

2

1

50

100

50

100

0

0

50

100

0.0

0

50

100

0.0

0

50

100

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

Layer 1

Layer 2

Layer3

Layer 4

Layer 5

BaMultiShapes

BaMultiShapes

4

BaMultishapes

+

1.0

6

Rules

Rules

4

2

0.5

2

0

0

50

100

0

50

100

0

50

100

0

50

100

0.0

0

50

100

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

Layer 1

Layer 2

Layer 3

Layer 4

Layer 5

3

1.0

0.05

0.05

0.05

s

2

0.5

0.00

0.00

0.00

1

50

100

0.0

50

100

0.05

50

100

-0.05

0

50

100

-0.05

0

50

100

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

Layer 1

Layer 2

Layer3

Layer 4

Layer 5

1.0

0.05

15

4

2

0.5

0.00

5

50

100

50

100

50

100

0.0

0

50

100

0.05

0

50

100

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

Layer 1

Layer 2

Layer3

Layer 4

Layer 5

1.0

0.05

7.5

S

4

0.5

0.00

2.5

2

0.0

0

0.0

-0.05

50

100

50

100

50

100

0

50

100

0

50

100

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

Layer 1

Layer 2

Layer 3

Layer 4

Layer 5

30

6

3

2

4

C11

Rules

10

...—

50

100

fo

50

100

0

50

100

50

100

0

50

100

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

Layer 1

Layer 2

Layer 3

Layer 4

Layer 5

10

1.0

0.05

4

BBBP

Ss

0.5

0.00

0

% Activated Nodes

50

100

% Activated Nodes

50

100

% Activated Nodes

50

100

0.0

% Activated Nodes

0

50

100

0.05

0

% Activated Nodes

50

100

Layer 1

Layer 2

Layer 3

Layer 4

Layer 5

4

t

3

1.0

20

s

TreeGrid

Rules

TreeGrid

2

2

0.5

50

100

50

100

50

100

50

100

0.0

0

50

100

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

Layer 1

Layer 2

Layer3

Layer 4

Layer5

BaCommunity

20

BaCommunity

10

BaCommunity

7.5

BaCommunity

7.5

1.0

Rules

Rules

5

2.5

2.5

0.5

0

T

H

0.0

0.0

0.0

50

100

50

100

0

50

100

0

50

100

0

50

100

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

Layer 1

Layer 2

Layer 3

Layer 4

Layer5

1.0

BaShapes

0.05

BaShapes

0.05

0.05

0.05

Rules

s

0.5

0.00

0.00

0.00

0.00

0.0

0.05

0.05

0.05

0.05

0

50

100

0

50

100

0

50

100

0

50

100

0

50

100

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

% Activated Nodes

activated. We observe as a general pattern that early layers have high variations on the activations, most likely due to the fact that they tend to recognise more general patterns. On the contrary later layers focus on more detailed patterns, drastically reducing the percentage of nodes that are activated.

H Ablation Study on Pruning

We performe an ablation study on the BBBP and BA2MOTIFS datasets to evaluate the effect of pruning strategies. We compare (i) layer-by-layer pruning , where the Hoyer regularization is applied sequentially starting from the last layer, and (ii) full pruning , where it is applied jointly to all layers. Table 3 reports the percentage decrease of non-zero weights (from the unpruned to the pruned model) for both strategies.

The results show that the layer-by-layer strategy better reduces the number of non-zero weights. In contrast, jointly optimizing all layers at once leads to weaker pruning due to interdependencies among rules: if a rule at layer ℓ depends on features from layer ℓ -1 , then pruning must respect this order. For this reason, pruning all layers together may incorrectly remove weights that are still needed in subsequent rules.

I Hyperparameters, Resources and Reproducibility

All the experiments, including those on GraphTrail, post-hoc methods and other self-explainable architectures, are documented in the supplementary material. The experiments were performed on a machine equipped with an Intel(R) Core(TM) i9-10900K CPU @ 3.70GHz and an NVIDIA GeForce RTX 4090. The implementation is done in PyTorch and PyTorch-Geometric and all the library versions are detailed in the environment specifics available in the supplementary material. In Table 4 and Table 5 we detail the hyperparameters of the models.

In Table 6 we report the average training times of GIN and LogiX-GIN. Although the LogiX-GIN training times are much higher compared to the ones of the black-box, it is always important to keep in mind that they allow for a full inspection of the single layers of the model. Before LogiX-GIN, no model or technique allowed for such level of explainability. Additionally, it is also important to keep in mind that, in the case of the GIN model, in order to have an explanation only of the last layer, we would still need to execute GraphTrail, which might take days to generate an explanation.

J Rule Pruning Statistics

Here, we report an analysis of the effects of our pruning strategy on the LogiX-GIN model. Table 7 shows the test accuracy and the number of non-zero weights before and after pruning on all the datasets in exam. We observe that the strategy does not impact the performances drastically. On the

contrary, in some cases we also record an improvement of the performances as the pruning encourages generalization in the model. The amount of non-zero weights reflects the number of rules identified in the experimental section. Indeed, we observe that the number of non-zero weights is directly linked with the number of rules that the model uses.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper presents an interpretable graph neural network. Its interpretability stems from binarizing each layer’s input and constraining the layer weights to be non-negative. These weights are translated into graded modal logic expressions that are more suitable for GNNs than binary expressions. The pipeline goes like this: Node features are binarized using TELL’s preprocessing step, which learns weights to threshold the features. Aggregating the binary features generates an integer-valued vector. A parametric Fourier step function is used to binarize it. The step function’s weights learn the integer ranges in which dimensions activate, acting as a proxy for counting. The ability to count facilitates the use of graded modal logic. The authors mention that their use of the sigmoid function hinders initial training and suggest pre-training the interpretable layers against a black-box GIN, where the interpretable layers emulate the GIN layers’ weights binarized using Gumbel-sigmoid activations. The proposed method’s novelty lies in using the Fourier step function as a proxy for counting facilitating the use of TELL layers on graphs.\n\nSTRENGTHS AND WEAKNESSES:\n# Strengths\n1. Graded Modal Logic is a good fit for GNNs and is likely to motivate future research on global explanations.\n2. The Fourier Step function is a neat way to binarize integer inputs.\n3. The interpretable model matches black-box performance on molecular and synthetic data.\n4. The authors have highlighted some of their model’s limitations.\n\n# Weaknesses\n1. **Limited originality:** The proposed method draws heavily from TELL (ECAI 24), with much of the architecture and pipeline inherited directly. The authors' contribution lies in using the Fourier step function as a proxy for counting facilitating the use of TELL layers on graphs. Other core aspects of the pipeline like input binarization, constrained positive weights and their conversion to graded modal logic are reused from TELL.\n\n2. **Missing baseline**: GNAN (NeurIPS '24) is a natural baseline for this work, yet it has not been compared against. Here’s the citation for your reference: Bechler-Speicher, Maya, Amir Globerson, and Ran Gilad-Bachrach. \"The intelligible and effective graph neural additive network.\" Advances in Neural Information Processing Systems 37 (2024): 90552-90578.\n\n3. Line 118: “demonstrated to not be properly faithful” This statement needs supporting evidence.\n\n4. **Binarizing vectors holding a semantic meaning**: Input binarization is appropriate when dimensions are independent and semantically meaningful—such as one-hot encoded atom types, categorical indicators, or continuous scalar features with clear interpretations (e.g., atomic radius). However, it is not suitable for dense embeddings like GloVe, where individual dimensions lack interpretability and meaning is distributed across the entire vector. Thresholding assumes each component is interpretable, which is not the case with such embeddings. The presence of specific values in certain dimensions may not correspond to anything meaningful, as the semantics are not localized. This limits the datasets on which the proposed method remains interpretable and should be clearly stated as a limitation.\n\n5. **Sigmoid struggling on 5 layers**: The paper mentions that the model struggles with initial learning due to its use of sigmoid functions. GNN’s are typically 2-5 layers deep. The authors have also used 5 layers. That’s not deep. Depth isn’t the reason the model is struggling. An empirical proof needs to show that the detrimental effect on training at such a shallow depth is caused by the sigmoid function.\n\n6. **Invalid pruning assumption**: Pruning layers individually seems problematic. Suppose we prune layer $L$, selecting a few prominent weights based on its current input. If we then prune layer $L−1$, its output changes, thus altering the input to layer $L$. This is problematic because layer $L$ was pruned based on the original input, which is no longer valid.\n\n7. **Dataset diversity**: All the datasets used in the paper are synthetic or molecular. Experiments on continuous valued features, especially the ones with dense features, e.g., GloVe embeddings, are missing.  A case study similar to MUTAG is needed on such datasets.\n\n8. **Spurious agreement between explanation and performance**: BAMultiShapes explanation is incorrect even though it exactly matches the one reported in GLGExplainer and PyTorch Geometric. It doesn't exclude all three motifs appearing together. Let me explain as there’s a bigger problem at hand. GLGExplainer’s authors have used one set of formulae to create the dataset (elaborated in their section 4.1) but visualized an incorrect version which has been picked up by PyG. Please see this [anonymous repo](https://anonymous.4open.science/r/bamultishapes_proof-BFD9) for the experiment proof. The formula presented in figure 1 and the corresponding results in table 1 makes me skeptical of the validity of the other results as well. That formula should not achieve 100% accuracy as the experiment should make clear.\n\n9. **Too many rules to be considered interpretable**: Even in simple, synthetic datasets like BA2Motifs, BAShapes, and TreeGrids, the last layer has 243, 46 and 26 active rules post-pruning. In these datasets, the class is identified by a single motif. Why do we need 243 rules for it? This number goes to 651 and 956 for Mutagenicity and NCI1. These many rules, even though individually interpretable, cannot be considered human interpretable in any meaningful sense. The cognitive load of understanding all 500+ rules together is too high for a human to grasp. In contrast, post-hoc global explainers generate a single concise formula for each of these datasets offering significantly greater human interpretability.\n\n10. **Instability:** The model is unstable. Table 2: BAMultiShapes has 829 active rules with an std of 360; Mutagencity has 651 active rules with an std of 530.\n\n11. **Ablations:** The authors should conduct the following ablation studies:\n    - Validate the need for pre-training by presenting results with and without pre-training.\n    - Pruning layers individually vs. pruning the model as a whole.\n\n12. The inability to utilize edge features should be stated in the limitations.\n\n13. Figure 6 is poorly visualized: nodes are very small; they should be colored instead of their outline being highlighted (which is barely visible); node IDs are irrelevant to the figure and should be replaced by node types.\n\n14. Minor corrections:\n    - Line 140: “using from” a word seems to be missing.\n    - Figure 2’s font is too small.\n    - In figure 10, $v’ \\in N(v)$ should be replaced with $v’ \\in N(v) \\cup {v}$\n    - Include the number of available cores in section G.\n    - Start the checklist on a new page.\n\nQUESTIONS:\n1. How is the non-negative constraint on weights preserved during gradient descent? Methods like non-negative matrix factorization (NMF) use hand-crafted updates to ensure such behavior.\n\n2. I have assumed the input node features are binarized using TELL’s preprocessing as mentioned in line 168. Is this correct?\n\n3. Line 223: Is the output of the sigmoid function binarized? If yes, what threshold is used?\n\n4. Why are the layers pruned individually, and why do it in reverse?\n\n5. How is the black-box GIN modified for pre-training so that the interpretable layer can mimic it? For example, are the hidden weights binarized actively during training or at the end of each epoch? Please provide these details.\n\n6. Is “alignment” the rule’s accuracy against the model’s predictions? And in LogiX-GIN, the model and rules are one and the same resulting in 100\\% alignment. Is my understanding correct?\n\n7. Please provide a figure similar to figure 2 for the non-mutagenic class of MUTAG and the negative class in BA2Motifs. I’m curious to see the explanations of the negative classes.\n\n8. Line 311: “exhibits less complexity and higher versatility than GraphTrail” What does versatile mean here? I contest the complexity part. Table 2 shows 651 active rules for Mutagenicity at layer 5 compared to 1 rule given by GraphTrail.\n\n9. Given the 243 active rules for BA2Motifs, how did the authors single out the explanation shown in figure 1. Same question for 829 active rules for BAMultiShapes, and Mutagenicity with 651 rules.\n\nLIMITATIONS:\nThe authors have mentioned most of their limitations. There are two that should also be included:\n1. The inability to utilize edge features should be stated in the limitations.\n\n2. Input binarization is appropriate when dimensions are independent and semantically meaningful—such as one-hot encoded atom types, categorical indicators, or continuous scalar features with clear interpretations (e.g., atomic radius). However, it is not suitable for dense embeddings like GloVe, where individual dimensions lack interpretability and meaning is distributed across the entire vector. Thresholding assumes each component is interpretable, which is not the case with such embeddings. The presence of specific values in certain dimensions may not correspond to anything meaningful, as the semantics are not localized. This limits the datasets on which the proposed method remains interpretable and should be clearly stated as a limitation.", "TITLE": "Official Review", "RECOMMENDATION": 4, "REVIEWER_CONFIDENCE": 5, "CLARITY": 3, "IMPACT": 2, "ORIGINALITY": 1, "DATE": "2025-06-21"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper combines logical explanation methods with self-explaining models by proposing a novel self-explaining graph neural network, **LogiX-GIN**. The model aims to automatically generate interpretable rules that adhere to *Graded Modal Logic (GML)*, while maintaining predictive performance and offering faithful, transparent explanations for its decisions.\n\nSTRENGTHS AND WEAKNESSES:\n## Strengths\n\n* While most prior work on logical explanation methods has focused on post-hoc techniques, this paper explores their integration into self-explaining models.\n* The proposed LogiX-GIN model provides interpretable explanations across multiple datasets without sacrificing predictive accuracy.\n\n## Weaknesses\n\n1. **Unsupported Claims**:\n   Several claims lack proper justification or references.\n\n   * Lines 117–119 state that LENs and instance-level post-hoc methods are not faithful, but no evidence or citations are provided.\n   * Lines 300–302 assert that LogiX-GIN highlights aromatic carbon structures as mutagenic, in contrast to GraphTrail’s NO₂ detection. However, the mutagenicity of simple aromatic rings is not well-established without specific functional groups like NO₂ or NH₂. These claims require citations or qualification.\n\n2. **Inconsistent and Unclear Notation**:\n   The paper lacks a notation table, and many symbols are ambiguous.\n\n   * In Line 159, the equation \\$y = \\sigma(XW^+ + b)\\$ uses \\$X\\$ and \\$y\\$ as vectors but with inconsistent capitalization. Since vectors are typically column vectors, the multiplication \\$XW^+\\$ is dimensionally incorrect—it should be \\$y = \\sigma(W^+x + b)\\$ if \\$x\\$ is a column vector.\n   * Similar notation issues occur in Equation 7 and Line 170, where \\$\\tilde{W} \\in \\mathbb{R}^I\\$ should be lowercase to avoid confusion with matrices.\n   * The semantics of \\$E(x, y)\\$ and the \\$\\models\\$ symbol are not defined.\n\n3. **Logical and Mathematical Errors**:\n\n   * The statement \\$y^{\\text{bin}}\\[j] = 1 \\Leftrightarrow \\sum\\_{i \\in S} W^+\\[i, j] > -b\\[j]\\$ omits the dependence on input \\$x\\$, contradicting the earlier expression \\$y = \\sigma(XW^+ + b)\\$.\n   * Line 169’s \\$\\tilde{x} = \\sigma(X \\odot \\exp(\\tilde{W}^+ \\tilde{b}))\\$ does not logically lead to the binarization formula in Line 171, and \\$\\tilde{W}^+\\$ is undefined.\n   * Lines 209–210 incorrectly state that the aggregated nodes \\$N(v) \\cup {v}\\$ correspond to \\$\\epsilon=1\\$ in Equation 2, when they actually match \\$\\epsilon=0\\$.\n\n4. **Unclear Formalism**:\n\n   * Lines 183–185 introduce GML formulas but use recursive expressions like \\$\\psi(x), \\psi\\_1(x), \\psi\\_2(x), \\theta(y)\\$ without explaining what constitutes a GML formula.\n   * Similarly, Lines 186–192 use the \\$\\models\\$ symbol in both definitions and explanations without clarification.\n   * The training procedure in Section 4 is under-specified, including a lack of clarity on the loss function and the distillation mechanism.\n\n5. **Limited Experimental Validation**:\n\n   * The experimental comparison only includes standard GIN and LogiX-GIN. Other self-explaining GNNs—such as VGIB, KerGNN, and Pi-GNN, all mentioned in the paper—should also be included for a more comprehensive evaluation.\n\nQUESTIONS:\n1. Consider including a diagram of the LogiX-GIN pipeline to illustrate data flow, binarization, distillation, and rule generation.\n2. Please reorganize the notation system and add a comprehensive notation table.\n3. Provide concrete examples of GML formulas to improve accessibility.\n4. The logic extraction seems to focus on input feature–output feature relationships. Yet, the experiment on “faithful global logic rules” presents node-level rules. How is this abstraction from feature-level to node-level achieved?\n\nLIMITATIONS:\nYes", "TITLE": "Official Review", "RECOMMENDATION": 2, "REVIEWER_CONFIDENCE": 4, "CLARITY": 1, "IMPACT": 2, "ORIGINALITY": 3, "DATE": "2025-06-23"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper tackles the challenge of providing explanations for GNNs by proposing a new ante-hoc method called LogicX-GIN. The proposed model incorporates some constraints in the way information is processed by the architecture, making the model amenable to rule extraction. Claims are tested on several datasets, showing that the model retains the predictive power of black-box GNNs while allowing for extracting graded model logic formulas.\n\nSTRENGTHS AND WEAKNESSES:\n# Strengths\n\n- Investigating novel paradigms for self-explainable GNNs is a very interesting direction, and adapting logic explanations to the ante-hoc setting is rarely studied\n\n- The paper makes a connection between the logical expressivity of GNNs and their relative logical explanations, which is a novel contribution\n\n- Albeit the description of the proposed contribution is unclear in some parts (see below), the architecture remains relatively simple and does not require articulated components or training losses, which is a pro to the proposed method\n\n\n# Weaknesses\n\n- The model is grounded on the TELL architecture, but this is only briefly explained in the Background. The self-containment of the paper would benefit from providing more context and background about TELL. For example, it is not clear how the thresholding of input features works, requiring the reader to read the original paper to fully understand it.\n\n- The architecture is presented as a sort of extension of the GIN architecture, but in practice, the aggregation function in Equation 4 shares only the sum over neighbors with the original GIN, making the connection not particularly strong. For example, GIN aggregates the self-loop by multiplying the $\\epsilon$ parameter, which is neglected in LogicX-GIN by setting $\\epsilon=1$. I believe the architecture can be presented in more general terms without grounding on GIN, but by referring to any GNN architecture with sum aggregation.\n\n- The proposed solution, in particular Equations 5 and 6, is introduced abruptly. The clarity of the proposed solution would greatly benefit from more intuition and explanation regarding it. I also checked Appendix A, but it is not enough to have a feeling of the functioning of that operation. I think that providing some toy analytical examples would be useful to understand how this counting-based step function works. \n\n- There is a mismatch between practice -- Eq. 5 in particular -- and the theory in Proposition 1. The proof is based on the fact that summing over $h_u^k$ yields, for each hidden dimension $j$, the count of neighbors where $h_u^k[j]=1$. Note that this is true as long as each $h_u^k[j]$ is binary (taking values either 1 or 0). However, according to Eq. 7, each $h_u^k[j]$ is not necessarily binary, as the sigmoid function can yield any value in between 0 and 1.\n\n- There is a conceptual contradiction regarding the pretraining stage. The authors claim that the sigmoid function of LogicX-GIN can create issues with model training, and therefore propose to train a standard GIN model to \"initialize\" model weights. Nonetheless, this standard GIN is still implemented with a sigmoid activation function, which supposedly inherits the same problem of LogicX-GIN (since they both use sigmoid activations). Even more, the standard GNN employs a Gumbel-sigmoid activation, which arguably makes the training even more unstable. Then, is it really the sigmoid activation function the problem when training LogicX-GIN from scratch?\n\n- The paper lacks the fundamental part of explaining how explanations are extracted from LogicX-GIN. The authors broadly refer to *the activations of the literals after the readout function can be interpreted as indicative patterns whose presence directly affects the final prediction* in line 292. Nonetheless, this is not trivial, and being part of the key contribution of the paper, it is definitely not explained well enough.\n\n\n\n# Minors\n\n- In line 1: Graphs do not necessarily *require* GNNs. There exist many alternatives to GNNs, like Graph Transformers and kernel-based approaches. Please update this line.\n\n- Given that the paper proposes to move beyond the usual paradigm of topological explanations, it might be worth including SE-GNNs that are not intrinsically topological, like [1,2,3]. This would make the related work section more complete.\n\n- Line 119: Please add some references to support the claim that post-hoc methods are not properly faithful.\n\n- Line 148: The statement: *The sum aggregation can distinguish between different neighborhood structures without ambiguity* is not correct. In fact, albeit expressive, GIN still has not reached full discrimination power as it is still upper bounded by 1-WL (see GIN's paper).\n\n- Line 157: *TELL is designed to be interpretable in terms of logic* sounds a bit vague. Please reformulate this statement to make it more precise.\n\n- Line 157: What do you mean by *feed-forward operation*? Is this a linear layer?\n\n- Equation 3: What is the difference between any $\\psi_i(x)$ and $\\theta(y)$? If they are simply different GML formulas, I would rather make the notation uniform and replace $\\theta$ with $\\psi_3$.\n\n- It is not clear whether the statement *which is necessary to represent counting operations in GML* in line 210 refers to the sum aggregation or to the fact that $\\epsilon=1$.\n\n- The caption of Figure 1 is not self-contained. Details should be added, like what is *alignment* (a proper formal definition is lacking even in Sec. 5), and whether those explanations are global or local.\n\n\n\n[1] Graphchef: Learning the recipe of your dataset. IMLH 2023\n\n\n[2] The intelligible and effective graph neural additive network. NeurIPS 2024\n\n\n[3] Beyond Topological Self-Explainable GNNs: A Formal Explainability Perspective. ICML 2025\n\nQUESTIONS:\n- **Q1**: What is the role of the clamp function in Equation 5? I was expecting $\\tilde{\\alpha}$ scores to be binary in $\\{0,1\\}$, but it seems that $\\tilde{\\alpha}$ can take other values, like $0.1$. Why is it done in this way?\n\n- **Q2**: Are $\\tilde{\\alpha}$ vectors or numbers? $\\alpha$ is defined in line 209 as the sum of embedding vectors, but in Eq. 6, you write $\\tilde{\\alpha}=1$, which indicates they are simple scalars. Maybe you mean $\\tilde{\\alpha}[j]=1$, where $j$ is a single hidden dimension?\n\n- **Q3**: Why is the additional Hoyer loss applied as a post-training step, rather than being added as an additional loss during training?\n\n- **Q4**: Can you please elaborate on lines 336-337? It is not clear what the underlying message the authors are trying to convey.\n\n- **Q5**: How does the model cope with graphs where node features are complex embeddings, like textual embeddings?\n\nLIMITATIONS:\nyes", "TITLE": "Official Review", "RECOMMENDATION": 4, "REVIEWER_CONFIDENCE": 4, "CLARITY": 1, "IMPACT": 3, "ORIGINALITY": 3, "DATE": "2025-07-02"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe authors introduce an inherently explainable GNN method. They use transparent explainable logic layer and graded modal logic to make an interpretable version of a GIN layer. This interpretable model is shown to have similar performance to the black-box GIN while extracting sensible logic rules for real-world datasets commonly used to evaluate explainable GNNs.\n\nSTRENGTHS AND WEAKNESSES:\nI think work on self-explainable GNNs is super important, as it greatly increases the trustworthiness of the methods (which post-hoc analysis can't necessarily provide). The proposed method in my opinion is a valuable contribution to this sub-field. As far as I know this is first method providing a self-explainable GNN of this type that uses logic rules. The fact that the final self-explainable method uses TELL layers is quite handy, as the model still is GPU accelerated and in principle differentiable (even though the gradients might be bad due to sigmoids). Which contrasts with some other self-explainable GNNs that exist.\nThe writing and presentation are clear. The benchmarks used are quite standard and the results look good.\n\nThe authors themselves acknowledge the two main weaknesses that I also see: 1) needing to start with a black-box GIN, which I think is a very minor issue and 2) that to extract explanations they rely on logic rules in the last layer. Here I think the method would be noticeably improved if authors provided a way to easily extract the full explanation that takes into account all layers. Of course this information is still in the model, so persistent user could pull it out manually, but it would be quite cumbersome.\n\nQUESTIONS:\nIn Node Attribution section, you state that attributions of LogiX-GIN are taken from the rules activated in the last layer. Is it instead possible to provide an end-to-end node attribution in your method, taking all layers into account? Something akin to running integrated gradients on the method. While I appreciate the value of having inspectable model rules, in practice, having good node attribution can be very useful for the end-user when inspecting a given graph.\n\nMaybe to get this 'full' explanation one could also just expand the logic rules of all the layers into one? Or does that in practice become unreasonably large and is unsimplyfiable?\n\nOne missing reference is GraphChef: https://openreview.net/pdf?id=IjMUGuUmBI which in some ways is quite similar: inherently explainable architecture based on GIN, with a transfer learning step from a black-box GIN, but uses decision trees instead of logic rules (thus not differentiable).\n\nLIMITATIONS:\nYes", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 4, "CLARITY": 3, "IMPACT": 2, "ORIGINALITY": 2, "DATE": "2025-07-02"}