LEAP: Local ECT-Based Learnable Positional Encodings for Graphs

## Abstract

Abstract Graph neural networks (GNNs) largely rely on the message-passing paradigm,
where nodes iteratively aggregate information from their neighbors. Yet,
standard message passing neural networks (MPNNs) face well-documented
theoretical and practical limitations. Graph positional encoding (PE) has
emerged as a promising direction to address these limitations. The Euler
Characteristic Transform (ECT) is an efficiently computable
geometric–topological invariant that characterizes shapes and graphs. In this
work, we combine the differentiable approximation of the ECT (DECT) and its
local variant ( ℓ ​ - ​ ECT \ell\mbox{-}\mathrm{ECT} ) to propose LEAP, a new end-to-end trainable local
structural PE for graphs. We evaluate our approach on multiple real-world
datasets as well as on a synthetic task designed to test its ability to
extract topological features. Our results underline the potential of ℓ ​ - ​ ECT \ell\mbox{-}\mathrm{ECT} -based encodings as a powerful component for graph representation
learning pipelines.

## 1 Introduction

Graphs are the preferred modality in numerous scientific domains, permitting the study of dyadic relationships in a highly efficient manner.
Their broad applicability comes with several challenges that make them harder to process with standard deep learning architectures.
Among these characteristics are
(i) a mixture of geometrical information (via node and edge features) and topological information (via the edges themselves),
(ii) highly variable cardinalities even within the same dataset, and
(iii) a lack of a canonical representation.
The development of suitable models is thus crucial for advancing the field of *graph representation learning*.
Contemporary research largely focuses on *message passing neural networks* (MPNNs), i.e., architectures that are based on local diffusion-like concepts.
While powerful, MPNNs also exhibit intrinsic limitations, which may pose severe obstacles for certain applications: For instance, MPNNs tend to lose “signals” in graphs of high diameter (Rusch et al., 2023, Zhang et al., 2023, Di Giovanni et al., 2023), and many architectures are incapable of efficiently leveraging substruture information (Chen et al., 2020).

As an alternative to pure MPNNs, inspired by the transformer architecture (Vaswani et al., 2017), recent work started focusing on *positional encodings* (PEs) and *structural encodings* (SEs) of graphs, denoting functions that assign embeddings to nodes based on locality or relational information, respectively (Dwivedi et al., 2023, Kreuzer et al., 2021, Rampášek et al., 2022).
Most PEs/SEs are based on *either* geometrical aspects (like coordinates, curvature, or distances) *or* topological aspects (like Laplacians or random walks), which may potentially limit their expressivity in practice. To overcome this,
we propose a new positional encoding that leverages *both* geometry *and* topology.
Our positional encoding, which we refer to as LEAP, affords end-to-end-training and is based on a *local* and *learnable* variant of the Euler Characteristic Transform (ECT), a geometrical-topological invariant that is easy to calculate and highly expressive.

Our paper contains the following contributions:

- 1.
We propose a new graph positional encoding based on local ECTs, which is highly flexible and permits end-to-end training.
- 2.
We observe that our method captures structural differences in graphs even in cases when the node features are *non-informative*.
- 3.
We conduct extensive experiments on benchmark datasets that demonstrate that our method yields *improved predictive power* in comparison to existing positional encodings when used in conjunction with graph neural networks.

## 2 Background

Before introducing our learnable positional encoding, we provide a
short self-contained summary of message-passing, positional encodings for Graphs and the
Euler Characteristic Transform.

### 2.1 Message Passing

Graph Neural Networks (GNNs) are specifically designed to operate on graph-structured data. A large subclass of GNNs are Message Passing Neural Networks (Gilmer et al., 2017, MPNNs).
MPNNs represent each node by a vector that is iteratively updated by aggregating neighboring representations. Hence, the state of a node $v$ at step $t$, denoted ${\bm{h}}_{v}^{(t)}$, is computed as

$$ ${\bm{h}}_{v}^{(t)}=\text{UPDATE}\left({\bm{h}}_{v}^{(t-1)},\text{AGGREGATE}\left(\{{\bm{h}}_{u}^{(t-1)}:u\in\mathcal{N}(v)\}\right)\right),$ (1) $$

where both AGGREGATE and UPDATE are learnable functions and $\mathcal{N}(v)$ denotes the neighbors of node $v$.
Following von Rohrscheidt & Rieck (2025), we refer to a graph ${\mathcal{G}}$ together with feature vectors for each of its nodes as a *featured graph*. We adopt the notation in the definition below:

A *featured graph* is a pair $({\mathcal{G}},x)$, where ${\mathcal{G}}$ is a (non-directed) graph, and $x$ is a map that assigns each node $v\in V({\mathcal{G}})$ a feature vector $x(v)\in\mathbb{R}^{d}$. We denote the set of nodes of ${\mathcal{G}}$ by $V({\mathcal{G}})$, and the set of edges by $E({\mathcal{G}})$.

Despite their popularity, common MPNNs are limited by phenomena like oversquashing (Di Giovanni et al., 2023), oversmoothing (Rusch et al., 2023, Zhang et al., 2023), or restricted expressive power (Xu et al., 2019, Chen et al., 2020). Multiple approaches have been proposed to address these challenges, for instance by
(i) modifying graph connectivity via virtual nodes (Cai et al., 2023, Grötschla et al., 2024),
(ii) combining message passing with global attention (Rampášek et al., 2022), or
(iii) imbuing a model with topology-based inductive biases (Verma et al., 2024, Horn et al., 2022).

### 2.2 Graph Positional Encodings

Inspired by positional encodings in Transformers (Vaswani et al., 2017), graph positional encodings (PEs) emerged as a way to inject structural information directly into node features. Architectures such as GPS (Rampášek et al., 2022) combine multiple PEs, enabling global-attention layers to incorporate graph structure. Graph PEs have also been shown to benefit standard MPNNs (Dwivedi et al., 2023; 2022, Ma et al., 2021, Verma et al., 2025). Rampášek et al. (2022) propose a categorization of graph PEs into *Positional Encodings* and *Structural Encodings*, further subdivided into *local*, *global*, or *relative* variants.
Two commonly-used graph positional encodings are the Random Walk Positional Encoding (Dwivedi et al., 2022, RWPE) and the Laplacian Positional Encoding (Maskey et al., 2022, LAPE), which have inspired several other approaches (Maskey et al., 2022, Grötschla et al., 2024, Lim et al., 2023, Rampášek et al., 2022), including learnable ones like SignNet (Lim et al., 2023). We describe these two PE strategies for a graph $\mathcal{G}$ below.

##### Random Walk Positional Encoding (RWPE).

For any node $v\in V(\mathcal{G})$, Dwivedi et al. (2022) define the $k$-dimensional RWPE of $v$, denoted by ${\bm{p}}_{v}^{\textnormal{RWPE}_{k}}$ as:

$$ ${\bm{p}}_{v}^{\textnormal{RWPE}_{k}}:=[\textbf{RW}_{vv},(\textbf{RW})^{2}_{vv},\ldots,(\textbf{RW})^{k}_{vv}]\in\mathbb{R}^{k},$ (2) $$

where $\textbf{RW}:={\bm{A}}({\mathcal{G}}){\bm{D}}({\mathcal{G}})^{-1}$ is the random walk matrix of the graph ${\mathcal{G}}$, ${\bm{A}}({\mathcal{G}})$ denotes the *adjacency matrix* of ${\mathcal{G}}$, and ${\bm{D}}({\mathcal{G}})$ denotes the *degree matrix* of ${\mathcal{G}}$. Rampášek et al. (2022) categorize RWPE as a *local structural encoding*.

##### Laplacian Positional Encoding (LaPE).

The *normalized Laplacian matrix* of $\mathcal{G}$ is given by ${\bm{L}}({\mathcal{G}})={\bm{I}}-{\bm{D}}({\mathcal{G}})^{-1/2}{\bm{A}}({\mathcal{G}}){\bm{D}}({\mathcal{G}})^{-1/2}$,
where ${\bm{I}}$ denotes the identity matrix.
The LaPE of the nodes in ${\mathcal{G}}$ are constructed from the eigendecomposition
of ${\bm{L}}({\mathcal{G}})={\bm{Q}}^{\top}\Lambda\ {\bm{Q}}$.
Given the eigenvalues sorted in ascending order
${\lambda^{(1)},\ldots,\lambda^{(K)}}$, with corresponding
eigenvectors ${{\bm{q}}^{(1)},\ldots,{\bm{q}}^{(K)}}$, Dwivedi et al. (2023) define the
$k$-dimensional LaPE (${\bm{p}}_{v}^{\textnormal{LaPE}_{k}}$) of a node $v$ as

$$ ${\bm{p}}_{v}^{\textnormal{LaPE}_{k}}:=[{\bm{q}}^{(i)}_{v},{\bm{q}}^{(i+1)}_{v},\ldots,{\bm{q}}^{(i+k)}_{v}]\in\mathbb{R}^{k},$ (3) $$

where $i$ is the index of the first non-trivial eigenvector. Since LaPE employs the eigendecomposition of the full graph, Rampášek et al. (2022) consider it to be a
*global positional encoding*.

### 2.3 The Euler Characteristic Transform (ECT)

The *Euler Characteristic Transform* (ECT) originated as a method to summarize simplicial complexes, i.e., higher-order domains, to which elements are added inductively (Turner et al., 2014).
We will specialize our exposition to the case of graphs, consisting of *vertices* and *edges*.
The *Euler characteristic* of a graph is a topological invariant, which is defined as the number of nodes minus the number of edges, sometimes permitting to *distinguish* between graphs that are not topologically equivalent.(^1^11Formally, homotopy-equivalent topological spaces have the same Euler characteristic.)
While possessing some descriptive power, the Euler characteristic remains limited as many topologically different graphs possess the same Euler characteristic.
However, by moving to a *multi-scale* variant of the Euler characteristic, we obtain the ECT, which combines geometrical and topological information to obtain an expressive representation.
Specifically, given a featured graph $({\mathcal{G}},x)$, we can project the node features along a one-dimensional subspace spanned by a unit vector $\theta\in\mathbb{S}^{d-1}$, referred to as a *direction*, and consider
the pre-image of the projection to obtain a monotonically increasing sequence
of subgraphs of ${\mathcal{G}}$.
Tracking the Euler characteristic along that sequence indexed by $t\in\mathbb{R}$ yields the *Euler Characteristic Curve* (ECC) in the direction of $\theta$.
Finally, the ECT is the map that assigns direction vectors
to their respective ECC. For graphs, it is defined as

$$ $\displaystyle\mathrm{ECT}\colon\mathbb{S}^{d-1}\times\mathbb{R}$ $\displaystyle\to\mathbb{Z}$ (4) $\displaystyle(\theta,t)$ $\displaystyle\mapsto\sum_{v\in V({\mathcal{G}})}\mathbbold{1}_{[-\infty,\langle\theta,x(v)\rangle]}(t)-\sum_{e\in E({\mathcal{G}})}\mathbbold{1}_{[-\infty,\max_{u\in e}\langle\theta,x(u)\rangle]}(t).$ $$

In the more general case of simplicial complexes, this equation is extended as an alternating sum of higher-order elements beyond edges, including triangles, tetrahedra, and so on.
Somewhat surprisingly, given a sufficiently large *finite* number of directions, the ECT is *injective* on geometric graphs and geometric (simplicial) complexes (Curry et al., 2022, Ghrist et al., 2018), that is, distinct inputs yield distinct ECTs.

One limiting factor to the applicability of the ECT in a deep learning setting is the
lack of differentiability with respect to the direction vectors and input
coordinates.
However, by approximating the indicator function of [Equation 4](https://arxiv.org/html/2510.00757v1#S2.E4) with a sigmoid function,
one obtains
the end-to-end *differentiable Euler Characteristic Transform* (Röell & Rieck, 2024, DECT), which affords the easy integration into deep learning pipelines via a computational layer.
This formulation of the ECT provides a *global* summary of a shape, but certain graph learning
tasks benefit from a *local* perspective of the graph around a node of interest.
As a *static*, i.e., non-trainable, extension to the ECT, the *local Euler Characteristic Transform* (von Rohrscheidt & Rieck, 2025, $\ell\mbox{-}\mathrm{ECT}$),
constitutes a variant based on local neighborhoods with favorable properties
for node classification.
Given a featured graph $(\mathcal{G},x)$ with $x\colon V(\mathcal{G})\to\mathbb{R}^{d}$,
and a vertex $v$, the *local ECT* of $v$ with respect
to $m\in\mathbb{N}$ is defined as

$$ $\ell\textnormal{-ECT}_{m}[{\mathcal{G}},x;v]:=\textnormal{ECT}[\mathcal{N}_{m}(v,{\mathcal{G}}),x|_{\mathcal{N}_{m}(v,{\mathcal{G}})}],$ (5) $$

where $\mathcal{N}_{m}(v,{\mathcal{G}})$ denotes a *local neighborhood* of $v$,
whose locality scale is controlled by the hyperparameter $m$.
The following result by von Rohrscheidt & Rieck (2025) relates the $\ell\mbox{-}\mathrm{ECT}$ to MPNNs.

Let $({\mathcal{G}},x)$ be a featured graph, and let $\{\ell\textnormal{-ECT}_{1}[{\mathcal{G}},x;v]\}_{v}$ be the set of the
1-hop $\ell$-ECTs of all the vertices $v\in V(G)$.
Then $\{\ell\textnormal{-ECT}_{1}[{\mathcal{G}},x;v]\}_{v}$ provides all the (non-learnable) needed information to perform a single message passing step on $({\mathcal{G}},x)$.

The required non-learnable information for a single message passing
step refers to the fact that for a given vertex $v$, one can
theoretically recover the features of the neighboring nodes from the
$\ell$-ECT.
This result highlights the power of the 1-hop $\ell$-ECT for graph
representation learning Moreover, von Rohrscheidt & Rieck (2025) also show that the $\ell\mbox{-}\mathrm{ECT}$ is sufficiently expressive to allow subgraph counting,
one of the limitations of traditional message passing architectures (Chen et al., 2020).
This illustrates that ECT-based methods can be more powerful than traditional
message passing neural networks in certain cases.

## 3 Methods

This section introduces the Local ECT and Projection PE (LEAP), a *learnable*
local structural graph PE based on the $\ell$-ECT. As part of this encoding, we
present strategies for projecting the ECT of a shape into a lower-dimensional
space.

### 3.1 ℓ \ell -ECT based Positional Encoding

Given a featured graph $(\mathcal{G},x)$ with $d$-dimensional node features,
which may be static (i.e., the original node features or another PE), or learned
(i.e., hidden states at some step of an MPNN), let $\mathbb{T}\subset[0,1]$ be
a finite set of thresholds and $\Theta\subset\mathbb{S}^{d-1}$ a finite set
of directions. The $k$-dimensional LEAP PE of a node $v\in V(\mathcal{G})$ is
constructed as follows:

- 1.
Compute the $m$-hop subgraph $\mathcal{N}_{m}(v,\mathcal{G})$ around
node $v$.
- 2.
Given the set of nodes $\{u_{1},\ldots,u_{n}\}=V(\mathcal{N}_{m}(v,\mathcal{G}))$, mean center their feature set $\{x(u_{1}),\ldots,x(u_{n})\}$
and divide each element by the maximum norm in the centered set to obtain
new features $\mathbb{F}=\{f(u_{1}),\ldots,f(u_{n})\}\subset\mathbb{S}^{d-1}$, where $f:V(\mathcal{N}_{m}(v,\mathcal{G}))\to\mathbb{F}$ denotes the mapping between each node in the $m$-hop and its
normalized feature vector.
- 3.
Compute the matrix ${\bm{M}}\in\mathbb{R}^{|\Theta|\times|\mathbb{T}|}$
whose $(i,j)$ entry is the differentiable approximation of the ECT of
$(\mathcal{N}_{m}(v,\mathcal{G}),f)$ at $(\theta_{i},t_{j})\in\Theta\times\mathbb{T}$.
- 4.
Lastly, a learnable projection $\phi:\mathbb{R}^{|\Theta|\times|\mathbb{T}|}\to\mathbb{R}^{k}$ maps ${\bm{M}}$ to a
vector $\text{PE}(v)\in\mathbb{R}^{k}$, which is the final positional
encoding of node $v$.

Figure: Figure 1: Steps for computing the LEAP PE using $1$-hop neighborhoods. (1) The neighborhood of a node in a featured graph is selected. (2) Normalization of the neighborhood features. (3) Computation of the differentiable ECT. (4) Projection of the matrix representation of the ECT to get the PE vector.
Refer to caption: images/leap.png

*LEAP* is *not* a static pre-processing step on the graph. On the
contrary, it can be integrated in Graph Learning architectures to be trained
on and end-to-end fashion.
With the previous remark, we highlight a key difference between LEAP and
well-established graph PEs such as LaPE, and RWPE. This is also an important
distinction from the previous use of the $\ell$-ECT, which was originally introduced as a static, non-learnable extension of node features, with neighborhood connectivity being disregraded as the ECT was calculated on node neighborhoods as if they were point clouds rather than graphs (von Rohrscheidt & Rieck, 2025).
In addition, LEAP permits the set of directions $\Theta$ to be randomly initialized and then *either* kept fixed *or* optimized during training. LEAP can also be applied to learned graph features and, since it integrates with any GCN, it is naturally applicable to both graph-level and node-level tasks. In contrast, the DECT on its own is geared to produce graph-level descriptors (Röell & Rieck, 2024).

Within the categorization of Rampášek et al. (2022), LEAP is a *local structural encoding*.

The locality of LEAP comes from computing each node’s encoding only from its $m$-hop subgraph. Thus, the locality of LEAP is controlled by the hop number used to build the subgraphs, which serves as a hyperparameter of the PE. By default, we suggest 1-hop neighborhoods, but we also describe two ways to control the locality of LEAP:

- •
Use a larger hop number $m$. This approach is straightforward, but it should be noted that two nodes may differ in their $m$-hop neighborhoods while becoming identical at $(m+1)$-hops.(^2^22For sufficiently large $m$, this strategy yields identical PEs for all nodes within the same connected component.)
- •
Alternatively, we compute LEAP multiple times for each node with increasing $m$, then concatenate the results to obtain a PE that captures how the $m$-hop neighborhoods evolve as $m$ grows.

We also note that two nodes in a graph that share identical $m$-hop neighborhoods receive the same LEAP PE, since the second step in the computation of the PE yields identical outputs. This aligns directly with the definition of *local structural encoding* given in Rampášek et al. (2022): *“Given a structural encoder of radius $m$, the more similar the $m$-hop subgraphs around two nodes are, the closer their local structural encoders will be.”*
Moreover, consider a node whose normalized $m$-hop neighborhood features form a
valid graph embedding.(^3^33In general there is no guarantee this will occur.)
If we could access the ECT of that subgraph rather than an approximation, then
by the injectivity results of the ECT (Ghrist et al., 2018, Curry et al., 2022) we
would have all the information required to recover the neighborhood’s
structure.(^4^44We design an experiment to test the ability of LEAP to capture topological features of a graph, see [Section 4.1](https://arxiv.org/html/2510.00757v1#S4.SS1).)

### 3.2 ECT projection strategies

Since LEAP aims to capture structural information, it should be invariant to
scaling and rotations of neighborhood features. Step 2 above addresses
normalization, but to minimize the effect of rotations, the projection in Step 4
should be *permutation invariant* with respect to the ECCs.
However, this requirement is often ignored in practice (Röell & Rieck, 2024).
In the remainder of this section, we present five
projection strategies for LEAP, some of which explicitly enforce this
invariance.

We “flatten” the $\ell\mbox{-}\mathrm{ECT}$ of each node into a vector ${\bm{v}}\in\mathbb{R}^{D}$ with $D=|\Theta|\cdot|\mathbb{T}|$, following Amézquita et al. (2021).
We then apply a linear projection by multiplying ${\bm{v}}$ with a learnable
matrix ${\bm{W}}\in\mathbb{R}^{k\times D}$.
This projection is *not* permutation invariant with respect to the ECC, and the
number of learnable parameters with respect to$|\Theta|$ and $|\mathbb{T}|$
is $\mathcal{O}(|\Theta|\cdot|\mathbb{T}|)$.

We treat the $\ell\mbox{-}\mathrm{ECT}$ of each node as a multichannel time series, where
thresholds act as time steps and each ECC defines a channel. Several 1D
convolutions are concatenated, and the resulting channels are averaged to
produce a vector that is used as an input to an MLP. This projection is *not* permutation
invariant with respect to the order of the directions,
and the number of learnable parameters with respect to $|\Theta|$ and $|R|$ is
$\mathcal{O}(|\Theta|+|\mathbb{T}|)$.

We treat the $\ell\mbox{-}\mathrm{ECT}$ of a node as a set of $|\mathbb{T}|$-dimensional vectors,
corresponding to the ECCs along different directions in $\Theta$, processing this set
using an architecture inspired by DeepSets (Zaheer et al., 2017): Given the set of
vectors corresponding to the ECCs we have
$\text{PE}=\text{MLP}_{2}(\sum_{\theta\in|\Theta|}\text{MLP}_{1}(\text{ECC}_{\theta}))$. This rojection
strategy is permutation invariant wrt. the directions of the ECT, and
its number of learnable parameters is independent of $|\Theta|$.

We treat the $\ell\mbox{-}\mathrm{ECT}$ of a node as a set of $|\mathbb{T}|$-dimensional
vectors, corresponding to the ECCs along the different directions in $\Theta$, and
process this set by a transformer encoder with a single attention head.
To obtain the PE, we apply an MLP to the sum of the generated ECC representations.
Due to the use of a self-attention without any
positional encoding, the projection is permutation invariant, and the number of
learnable parameters depends on $|\mathbb{T}|$ but not on $|\Theta|$.

As a variant of the previous project, instead of feeding the transformer encoder the set of ECCs directly, we concatenate each $\text{ECC}_{\theta}$ with the corresponding direction $\theta\in\Theta$ before passing it to the encoder. This yields a permutation invariant projection strategy, while incorporating information about the directions along which the ECCs were computed.

## 4 Experiments

Our experiments are designed to evaluate different aspects of LEAP. We investigate
(i) its ability to capture structural properties *independent* of node features using a synthetic dataset,
(ii) its impact on the performance of different graph architectures and the effect of learning the directions of the transform, using multiple benchmark datasets with common PEs as baselines,
(iii) its performance on a large-scale dataset with 202,579 graphs (Chen et al., 2019),
(iv) its behavior when applied to learned node features in the *HIV* dataset (Wu et al., 2018), and
(v) the effect of hyperparameters (via ablations).
In tables and figures, *LEAP-L* denotes that the directions for LEAP were randomly
initialized and learned during training, while *LEAP-F* denotes that the
directions remained fixed.

### 4.1 Synthetic Dataset

We introduce a synthetic dataset of 40,000 graphs to test whether LEAP can capture structural differences *independent* of node features.
Each graph has three nodes and contains either zero, one, two, or three edges, yielding a classification task with four classes based on edge count.
The node features are uniformly sampled from the unit disk $D_{1}\subset\mathbb{R}^{2}$ to make the task
a purely structural task.
As architectures we use a standard GCN and GAT architecture as base models.
We then compare this to the same model enhanced with LEAP added as structural
positional encoding.
For the computation of the ECT used in LEAP, we use 16 directions with a resolution
of 16, hence summarizing each graph into a $16\times 16$ ECT.
The models enhanced with LEAP achieve a perfect prediction score of
$100.0\pm 0.0$, demonstrating the ability of our approach to capture
structural properties independent of the node features.
In contrast, the GCN and GAT models do not obtain perfect scores ($71.83\pm 0.27$ and
$69.44\pm 0.82$ respectively), demonstrating their inability to capture relevant
structural graph properties when informative node features are not available.

### 4.2 Classifying real-world datasets

**Table 1: Best approach (architecture, PE strategy, and projection strategy) and relative accuracy improvement with respect to the worst performing baseline for TU classification datasets. In all cases the best result was achieved using our PE strategy.**
| Dataset | Best Method | Worst | Best | Gain (%) |
| --- | --- | --- | --- | --- |
| Letter-H | NoMP + LEAP-L+ 1D Conv | $41.6$ | $81.6$ | $96.2$ |
| Letter-M | NoMP + LEAP-L+ 1D Conv | $57.8$ | $88.5$ | $53.1$ |
| Letter-L | NoMP + LEAP-L+ 1D Conv | $80.4$ | $98.0$ | $21.9$ |
| Fingerprint | NoMP + LEAP-L+ Linear | $48.8$ | $55.7$ | $14.1$ |
| COX2 | GAT + LEAP-L+ Attn w/ PE | $77.7$ | $80.1$ | $3.1$ |
| BZR | NoMP + LEAP-L+ Linear | $78.3$ | $84.7$ | $8.2$ |
| DHFR | GCN + LEAP-L+ Attn w/ PE | $70.1$ | $77.6$ | $10.7$ |

We evaluate LEAP on several graph classification datasets from the TU benchmark (Morris et al., 2020).
Our aim is to evaluate
(i) the capacity of LEAP to enhance existing graph neural networks with structural information,
(ii) compare LEAP with existing PEs, and
(iii) investigate in which architecture LEAP induces the largest increase in accuracy.
Of particular interest is the evaluation on the *Alchemy*(^5^55In fact, we use the *Alchemy_full* dataset.) (Chen et al., 2019) dataset,
as the regression targets are rotation invariant with respect to the node features.
For this dataset, we normalize the regression targets so that all 12 tasks are on the same scale.
For the *HIV* dataset (Wu et al., 2018), where nodes have categorical features, we exploit the end-to-end differentiability of the ECT by extending the architecture with a learnable embedding layer that maps these features into $\mathbb{R}^{3}$, where LEAP is computed.

##### Architectures.

To evaluate the efficacy of LEAP, we fix three backbone architectures to which
we add various types of positional encoding.
The three backbone architectures are
(i) a GCN (Kipf & Welling, 2017);
(ii) a GAT (Veličković et al., 2018); and
(iii) NoMP (“no message passing”), a model that we introduce based on a transformer encoder, which treats node features as an unordered set, thus ignoring the graph structure.
Following Maggs et al. (2024), we implement the GCN and GAT architectures with five message-passing layers and 32-dimensional hidden states.
For the *Alchemy* dataset, we scale the architectures to $10$ layers with
$64$-dimensional hidden states.
The NoMP architecture projects node features into a $16$-dimensional latent space with a linear layer, followed by a single self-attention layer that produces a $16$-dimensional state for each node. The final classification is performed by a feedforward layer. The hyperparameters of this model were chosen to match the parameter count of GCN/GAT.
By design, NoMP ignores graph structure unless provided through positional encodings, thus permitting us to directly evaluate the ability of each PE to encode relevant structural properties.
Finally, as positional encodings, we consider the following baselines:
(i) no positional encoding;
(ii) RWPE, which, like LEAP, is a local structural PE under the categorization of Rampášek et al. (2022), making it a particularly relevant baseline, and
(iii) LaPE, a widely used graph PE that, unlike LEAP, captures global positional information.

##### Experimental setup.

All experiments use 5-fold cross-validation and are trained with the Adam optimizer
for up to $100$ epochs with early stopping enabled.
As a loss term, we use *cross entropy loss* except for the *Alchemy* dataset,
where we use a mean squared error loss.
We use 10-dimensional PEs for all types and datasets. The only difference between the backbones with or without a PE is that the input dimension of the backbone increases by 10 when a PE is used.
The Euler Characteristic Transform in LEAP is calculated with $16$ directions and $16$ thresholds.
To simplify the setup, we keep all hyperparameters concerning each of the projection strategies of LEAP *fixed* across all datasets. Despite this, as we describe below, we observe high predictive performance across a variety of datasets.

#### Results

[Table 4](https://arxiv.org/html/2510.00757v1#S4.T4) reports the results for LEAP and the baselines in
combination with different architectures across the various classification datasets.
For every dataset–architecture combination, the two LEAP variants (F/L) achieve
the best and second-best performance, respectively.
When combined with GCN and NoMP architectures, *learning* the directions of LEAP
consistently improves performance in comparison to keeping them fixed.
For GAT, learning the directions slightly reduces performance compared to the fixed
variant of LEAP in 3 of the 7 datasets.
For all datasets, the overall best-performing architecture–PE combination always uses
LEAP with learned directions.

Figure: *Alchemy*
Refer to caption: images/gcn_alchemy_large.png

[Table 1](https://arxiv.org/html/2510.00757v1#S4.T1) reports the relative increase of the best-performing method
compared to the worst-performing method.
We observe the largest relative gains from using LEAP on the *Letter*
and *Fingerprint* datasets.
By contrast, for the Small Molecule datasets (*COX2*, *BZR*, *DHFR*) the advantage over the
baselines is less pronounced, likely due to their smaller size, which makes it
harder to benefit from richer features. Within this domain, we observe the largest
improvement on *DHFR*, the largest dataset among the
three (750), though still much smaller than *Letters* or *Fingerprint* (2250).
An interesting observation from [Table 4](https://arxiv.org/html/2510.00757v1#S4.T4) is that NoMP
without Positional Encoding outperforms baseline GNNs on the
*Letter-High* and *Letter-Low* datasets.
This highlights the limitations of MPNNs, as in some cases models with *no*
structural information can achieve better results.

We also evaluate LEAP on the *Alchemy* and
*HIV* datasets from the TU Benchmark using the same setup as described above.
The *Alchemy* dataset is significantly larger compared to the other datasets allowing
LEAP to extract more meaningful information from the data.
For the *Alchemy* dataset, we show the $R^{2}$ score and for the *HIV* dataset, we report AUROC,
due to large class imbalances.
[Figure 2](https://arxiv.org/html/2510.00757v1#S4.F2) shows the results for LEAP with the GCN
backbone and the various projection methods, showing a clear advantage for LEAP (with
learned directions) over all baselines.
For the *HIV* dataset, results exhibit a large degree of variability, and this is the only case where
neither of the two LEAP variant (L/F) outperforms all baselines. Still, both
variants surpass RWPE, which is in the same category of
*local structural encodings*.
LaPE yields the strongest performance, suggesting that *global positional* information, which cannot be captured by LEAP, may be particularly relevant for this dataset.
The full results are provided in [Figure 4](https://arxiv.org/html/2510.00757v1#A1.F4) in the Appendix.

### 4.3 Ablations

**Table 2: Surprisingly, increasing the neighborhood size ($\mathcal{N}_{m}$) does not improve the efficacy of LEAP, showing that the $1$-hop neighborhood is already sufficient.**
| Method | $\mathcal{N}_{m}$ | Letter-H | Letter-M | Letter-L |
| --- | --- | --- | --- | --- |
| LEAP-F | 1 | $81.29$ p m 1.91 | $88.0$ p m 1.89 | $96.27$ p m 0.84 |
| 2 | $74.44$ p m 3.26 | $84.31$ p m 0.76 | $94.13$ p m 1.05 |  |
| 1, 2 | $77.91$ p m 1.82 | $84.76$ p m 1.4 | $96.09$ p m 0.34 |  |
| LEAP-L | 1 | $80.62$ p m 3.58 | $86.49$ p m 2.2 | $96.18$ p m 1.24 |
| 2 | $72.76$ p m 2.66 | $85.11$ p m 1.29 | $93.38$ p m 0.84 |  |
| 1, 2 | $78.13$ p m 2.83 | $85.96$ p m 1.42 | $95.64$ p m 1.51 |  |

After having established that LEAP captures essential structural information to
be used with multiple graph neural network architectures, we further aim to
investigate the sensitivity of LEAP with respect to its various components.
In particular we hope to further understand how
(i) the choice of projection method,
(ii) the number of hops, and
(iii) the embedding dimension
impact the performance of LEAP.

##### Projection strategies.

We repeated all experiments using the five proposed LEAP projection strategies such
that each projection strategy has approximately similar small parameter budgets, comprising 1K–5K
parameters.
[Table 5](https://arxiv.org/html/2510.00757v1#A3.T5) in the Appendix reports the results; and we find *no* single
projection consistently outperformed the others, showing the best projection to be
dependent on the dataset–architecture combination.
However, a remarkable fact is that learnable directions did *on average* outperform
the fixed set of directions, underpinning the benefits of learnable directions as compared
to using them as static features.

**Table 3: Ablation study with respect to the embedding dimension of the projection. LEAP is stable with respect to the dimension and consistently performs well.**
| Emb. | PE | Letter-H | Letter-M | Letter-L |
| --- | --- | --- | --- | --- |
| 2 | LaPE | $66.31$ p m 1.2 | $94.71$ p m 1.29 | $76.76$ p m 1.95 |
| RWPE | $73.82$ p m 2.0 | $94.62$ p m 0.51 | $83.47$ p m 1.68 |  |
| LEAP-F | $81.16$ p m 1.66 | $96.27$ p m 1.47 | $86.76$ p m 1.86 |  |
| LEAP-L | $78.53$ p m 3.3 | $95.56$ p m 0.31 | $87.38$ p m 0.99 |  |
| 5 | LaPE | $64.44$ p m 3.54 | $94.22$ p m 0.61 | $82.09$ p m 1.64 |
| RWPE | $75.64$ p m 1.18 | $94.67$ p m 0.96 | $85.82$ p m 0.76 |  |
| LEAP-F | $79.78$ p m 0.57 | $96.98$ p m 0.25 | $86.76$ p m 1.11 |  |
| LEAP-L | $80.4$ p m 1.41 | $96.44$ p m 0.59 | $88.36$ p m 0.64 |  |
| 10 | LaPE | $65.02$ p m 1.58 | $91.11$ p m 2.23 | $76.93$ p m 2.52 |
| RWPE | $79.24$ p m 1.43 | $94.67$ p m 0.97 | $84.53$ p m 1.32 |  |
| LEAP-F | $80.13$ p m 2.04 | $96.68$ p m 0.78 | $86.59$ p m 2.01 |  |
| LEAP-L | $80.68$ p m 2.42 | $96.99$ p m 1.05 | $87.24$ p m 2.31 |  |
| 20 | LaPE | $64.8$ p m 2.49 | $93.24$ p m 0.96 | $77.64$ p m 2.12 |
| RWPE | $76.76$ p m 1.36 | $95.38$ p m 1.12 | $86.49$ p m 1.21 |  |
| LEAP-F | $80.84$ p m 1.89 | $95.56$ p m 0.65 | $87.42$ p m 0.75 |  |
| LEAP-L | $79.91$ p m 1.53 | $96.4$ p m 0.79 | $86.89$ p m 1.56 |  |

##### Locality.

We study the effect of the locality parameter in LEAP by repeating the
experiments on the *Letter* datasets, originally performed with $1$-hop
neighborhoods, using instead $2$-hop neighborhoods and the concatenation of
LEAP embeddings from $1$- and $2$-hop neighborhoods.(^6^66In the concatenation setting, each embedding is computed with half the target dimension so that the final representation matches the dimension of the other approaches.)
For this ablation, we use the NoMP model so that the models can only
access structural information through the PE, and we use *attention with PE* as the LEAP projection strategy.
[Table 2](https://arxiv.org/html/2510.00757v1#S4.T2) shows that the $1$-hop neighborhood yields the best performance across all
datasets, followed by the concatenated $1$- and $2$-hop version.

##### PE dimension.

To better understand the effect of increasing the embedding dimension for the projection
strategies, we vary the size of the embedding dimension on the *Letter* datasets.
The original experiment was ran with PE dimension $10$ for both LEAP and the baselines,
and we now repeat the experiment with the embedding dimension set to $\{2,5,10,20\}$.
As before, we fix the architecture to NoMP so that models access structural
information only through the PE, and use *attention with PE* as the
projection strategy for LEAP.
The results in [Table 3](https://arxiv.org/html/2510.00757v1#S4.T3) show that
across all the evaluated PE dimensions and datasets, LEAP outperforms both
RWPE and LaPE.

**Table 4: Accuracy results for different PE strategies when using a GCN and GAT architectures for multiple Computer Vision datasets from TU Benchmark. Best results are bold green, second best are green, and worst are red. For every dataset, our approach achieves the best and second best results.**
| Model | PE | COX2 | BZR | DHFR | Letter-H | Letter-M | Letter-L | Fingerprint |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| GCN | No PE | $77.9$ p m 1.0 | $81.9$ p m 3.3 | $71.6$ p m 1.4 | $41.6$ p m 4.1 | $63.5$ p m 2.0 | $80.4$ p m 1.0 | $48.8$ p m 1.4 |
| RWPE | $78.4$ p m 0.5 | $79.5$ p m 2.2 | $73.0$ p m 2.4 | $60.9$ p m 1.7 | $68.9$ p m 2.7 | $83.2$ p m 1.4 | $49.4$ p m 0.6 |  |
| LaPE | $78.4$ p m 0.9 | $80.3$ p m 1.2 | $70.4$ p m 2.8 | $55.3$ p m 2.6 | $75.8$ p m 2.6 | $89.2$ p m 1.2 | $48.1$ p m 1.8 |  |
| LEAP-F | $79.2$ p m 0.6 | $82.5$ p m 2.4 | $74.1$ p m 5.2 | $72.2$ p m 3.3 | $82.6$ p m 1.4 | $95.8$ p m 1.1 | $55.6$ p m 1.1 |  |
|  | LEAP-L | $79.4$ p m 1.0 | $82.5$ p m 1.6 | $77.6$ p m 2.8 | $74.2$ p m 1.5 | $83.6$ p m 1.3 | $96.0$ p m 0.9 | $55.1$ p m 1.2 |
| GAT | No PE | $78.2$ p m 0.6 | $80.5$ p m 2.0 | $73.7$ p m 1.8 | $41.9$ p m 3.2 | $58.4$ p m 3.7 | $89.4$ p m 0.7 | $50.5$ p m 0.6 |
| RWPE | $79.0$ p m 1.4 | $78.3$ p m 1.1 | $70.9$ p m 2.4 | $63.0$ p m 3.0 | $69.0$ p m 1.8 | $90.8$ p m 1.5 | $50.4$ p m 0.8 |  |
| LaPE | $77.9$ p m 1.0 | $80.3$ p m 1.2 | $70.4$ p m 2.7 | $54.7$ p m 5.3 | $75.2$ p m 2.3 | $89.6$ p m 1.5 | $48.9$ p m 1.0 |  |
| LEAP-F | $79.2$ p m 1.6 | $82.0$ p m 3.2 | $75.7$ p m 3.0 | $70.2$ p m 2.2 | $83.2$ p m 1.1 | $95.8$ p m 0.8 | $55.1$ p m 0.6 |  |
|  | LEAP-L | $80.1$ p m 2.2 | $83.7$ p m 2.9 | $76.5$ p m 3.8 | $73.5$ p m 2.1 | $82.4$ p m 1.6 | $95.2$ p m 0.9 | $54.9$ p m 0.7 |
| NoMP | No PE | $77.9$ p m 0.8 | $79.8$ p m 2.6 | $70.1$ p m 3.4 | $63.4$ p m 1.0 | $57.8$ p m 0.9 | $89.7$ p m 1.3 | $50.7$ p m 0.5 |
| RWPE | $77.7$ p m 1.3 | $80.9$ p m 1.7 | $73.3$ p m 1.5 | $79.2$ p m 1.4 | $84.5$ p m 1.3 | $94.7$ p m 1.0 | $51.3$ p m 0.7 |  |
| LaPE | $77.7$ p m 1.0 | $81.2$ p m 3.2 | $70.5$ p m 3.5 | $65.0$ p m 1.6 | $76.9$ p m 2.5 | $91.1$ p m 2.2 | $50.5$ p m 1.2 |  |
| LEAP-F | $79.0$ p m 0.6 | $83.2$ p m 1.7 | $74.3$ p m 6.1 | $81.3$ p m 1.9 | $88.0$ p m 1.9 | $97.2$ p m 0.3 | $55.7$ p m 1.1 |  |
|  | LEAP-L | $78.6$ p m 0.8 | $84.7$ p m 2.7 | $75.7$ p m 2.7 | $81.6$ p m 1.9 | $88.5$ p m 2.5 | $98.0$ p m 0.4 | $56.3$ p m 1.4 |

##### DECT hyperparameters and comparison.

We assessed LEAP’s sensitivity to the DECT hyperparameters by varying the number of directions in $\{2,4,8,16,32\}$ and smoothing parameter in $\{2,4,8,16,32,64,128\}$. LEAP remained robust, outperforming baselines across all settings; see Figure [8](https://arxiv.org/html/2510.00757v1#A3.F8) in the Appendix.
Finally, [Table 6](https://arxiv.org/html/2510.00757v1#A3.T6) in the Appendix summarizes the comparison of LEAP with DECT for graph classification tasks.
LEAP outperforms two variants of the DECT (with different parameter budgets) on most datasets, which further underscores the utility of learnable directions.

## 5 Conclusion and future work

We presented *LEAP*, a new *learnable local structural positional encoding* for graphs based on the $\ell\mbox{-}\mathrm{ECT}$. To the best of our knowledge, this is the *first* approach to integrate the $\ell\mbox{-}\mathrm{ECT}$ into deep learning architectures in an end-to-end trainable fashion. Our experiments show that LEAP consistently outperforms established baselines across multiple architectures and datasets, with learned directions further improving performance in most tasks, thereby highlighting the benefits of making this step trainable. Additionally, we introduced a synthetic task in which our approach achieved perfect accuracy, demonstrating its ability to capture topological information independent of node features, which the evaluated MPNNs (GCN/GAT) alone failed to recover.
Taken together, these results underscore the potential of $\ell\mbox{-}\mathrm{ECT}$ encodings for *topological deep learning* (Papamarkou et al., 2024) in general and graph representation learning tasks specifically.
LEAP is particularly well-suited to provide local structural information to architectures that rely on global attention mechanisms, where graph structure is not directly modeled and multiple PEs are often combined to capture complementary notions of graph position.

##### Limitations.

While LEAP provides a learnable way to capture local structural information. First, it is not a purely structural PE, as it requires *node features* to compute the ECTs. However, these features can be *learned*, and in the synthetic dataset, our approach succeeded even though the features were irrelevant to the prediction targets. Second, LEAP relies on a differentiable approximation of the discretized ECT applied to normalized $m$-hop subgraphs, which are not necessarily geometric, so the theoretical guarantees of the exact ECT (e.g., injectivity) may not fully carry over; we expect this to be one interesting focus for future work. Finally, unlike other graph PEs, such as LaPE or RWPE, where the only hyperparameter is the embedding dimension, LEAP introduces several hyperparameters (among others, a smoothing parameter of the ECT approximation, the number of directions, and the number of discretization steps). In practice, however, we fixed these across datasets and architectures and nevertheless observed consistently strong performance, and our ablation studies further demonstrated the robustness to these choices.

##### Future work.

We envision several directions for future research. Combining LEAP with positional encodings that capture complementary aspects of graph structure and embedding it within more sophisticated architectures may further improve performance and expressivity. Another promising line is to make the ECT step fully differentiable: Instead of discretizing along a fixed grid, treating thresholds as trainable parameters would allow the model to focus on informative regions and optimize their positions jointly with the other parameters. Finally, since the ECT can be applied to higher-order datasets (Ballester et al., 2025, Hoppe et al., 2025) as well, we believe that LEAP could be extended to this modality, thus serving as a generalizable addition to the topological deep learning toolbox.

## Reproducibility Statement

The anonymized code to reproduce our experiments are provided
in the supplementary materials.
The experiments used a fixed seed and the full configurations can be found in the experiments folder in the supplementary materials.

## References

- Amézquita et al. (2021)
Erik J Amézquita, Michelle Y Quigley, Tim Ophelders, Jacob B Landis, Daniel
Koenig, Elizabeth Munch, and Daniel H Chitwood.
Measuring hidden phenotype: Quantifying the shape of barley seeds
using the Euler characteristic transform.
*in silico Plants*, 4(1):diab033, 12 2021.
- Ballester et al. (2025)
Rubén Ballester, Ernst Röell, Daniel Bīn Schmid, Mathieu Alain, Sergio
Escalera, Carles Casacuberta, and Bastian Rieck.
MANTRA: The manifold triangulations assemblage.
In *International Conference on Learning Representations*, 2025.
URL [https://openreview.net/forum?id=X6y5CC44HM](https://openreview.net/forum?id=X6y5CC44HM).
- Cai et al. (2023)
Chen Cai, Truong Son Hy, Rose Yu, and Yusu Wang.
On the connection between MPNN and graph transformer.
In Andreas Krause, Emma Brunskill, Kyunghyun Cho, Barbara Engelhardt,
Sivan Sabato, and Jonathan Scarlett (eds.), *Proceedings of the 40th
International Conference on Machine Learning*, volume 202 of
*Proceedings of Machine Learning Research*, pp. 3408–3430. PMLR,
2023.
- Chen et al. (2019)
Guangyong Chen, Pengfei Chen, Chang-Yu Hsieh, Chee-Kong Lee, Benben Liao,
Renjie Liao, Weiwen Liu, Jiezhong Qiu, Qiming Sun, Jie Tang, et al.
Alchemy: A quantum chemistry dataset for benchmarking ai models.
*arXiv preprint arXiv:1906.09427*, 2019.
- Chen et al. (2020)
Zhengdao Chen, Lei Chen, Soledad Villar, and Joan Bruna.
Can graph neural networks count substructures?
*Advances in Neural Information Processing Systems*,
33:10383–10395, 2020.
- Curry et al. (2022)
Justin Curry, Sayan Mukherjee, and Katharine Turner.
How many directions determine a shape and other sufficiency results
for two topological transforms.
*Transactions of the American Mathematical Society, Series B*,
9(32):1006–1043, 2022.
- Di Giovanni et al. (2023)
Francesco Di Giovanni, Lorenzo Giusti, Federico Barbero, Giulia Luise, Pietro
Lio, and Michael M Bronstein.
On over-squashing in message passing neural networks: The impact of
width, depth, and topology.
In *International Conference on Machine Learning*, pp. 7865–7885. PMLR, 2023.
- Dwivedi et al. (2022)
Vijay Prakash Dwivedi, Anh Tuan Luu, Thomas Laurent, Yoshua Bengio, and Xavier
Bresson.
Graph neural networks with learnable structural and positional
representations.
In *International Conference on Learning Representations*, 2022.
URL [https://openreview.net/forum?id=wTTjnvGphYj](https://openreview.net/forum?id=wTTjnvGphYj).
- Dwivedi et al. (2023)
Vijay Prakash Dwivedi, Chaitanya K Joshi, Anh Tuan Luu, Thomas Laurent, Yoshua
Bengio, and Xavier Bresson.
Benchmarking graph neural networks.
*Journal of Machine Learning Research*, 24(43):1–48, 2023.
- Ghrist et al. (2018)
Robert Ghrist, Rachel Levanger, and Huy Mai.
Persistent homology and Euler integral transforms.
*Journal of Applied and Computational Topology*, 2(1):55–60, 2018.
- Gilmer et al. (2017)
Justin Gilmer, Samuel S. Schoenholz, Patrick F. Riley, Oriol Vinyals, and
George E. Dahl.
Neural message passing for quantum chemistry.
In Doina Precup and Yee Whye Teh (eds.), *Proceedings of the
34th International Conference on Machine Learning*, volume 70 of
*Proceedings of Machine Learning Research*, pp. 1263–1272. PMLR,
06–11 Aug 2017.
URL [https://proceedings.mlr.press/v70/gilmer17a.html](https://proceedings.mlr.press/v70/gilmer17a.html).
- Grötschla et al. (2024)
Florian Grötschla, Jiaqing Xie, and Roger Wattenhofer.
Benchmarking positional encodings for gnns and graph transformers.
*arXiv preprint arXiv:2411.12732*, 2024.
- Hoppe et al. (2025)
Josef Hoppe, Vincent P. Grande, and Michael T. Schaub.
Don’t be afraid of cell complexes! An introduction from an applied
perspective.
*arXiv preprint arXiv:2506.09726*, 2025.
- Horn et al. (2022)
Max Horn, Edward De Brouwer, Michael Moor, Yves Moreau, Bastian Rieck, and
Karsten Borgwardt.
Topological graph neural networks.
In *International Conference on Learning Representations*, 2022.
URL [https://openreview.net/forum?id=oxxUMeFwEHd](https://openreview.net/forum?id=oxxUMeFwEHd).
- Kipf & Welling (2017)
Thomas N. Kipf and Max Welling.
Semi-supervised classification with graph convolutional networks.
In *International Conference on Learning Representations*, 2017.
URL [https://openreview.net/forum?id=SJU4ayYgl](https://openreview.net/forum?id=SJU4ayYgl).
- Kreuzer et al. (2021)
Devin Kreuzer, Dominique Beaini, Will Hamilton, Vincent Létourneau, and
Prudencio Tossou.
Rethinking graph transformers with spectral attention.
In *Advances in Neural Information Processing Systems*,
volume 34, pp. 21618–21629. Curran Associates, Inc., 2021.
- Lim et al. (2023)
Derek Lim, Joshua David Robinson, Lingxiao Zhao, Tess Smidt, Suvrit Sra, Haggai
Maron, and Stefanie Jegelka.
Sign and basis invariant networks for spectral graph representation
learning.
In *The Eleventh International Conference on Learning
Representations*, 2023.
URL [https://openreview.net/forum?id=Q-UHqMorzil](https://openreview.net/forum?id=Q-UHqMorzil).
- Ma et al. (2021)
Liheng Ma, Reihaneh Rabbany, and Adriana Romero-Soriano.
Graph attention networks with positional embeddings.
In Kamal Karlapalem, Hong Cheng, Naren Ramakrishnan, R. K. Agrawal,
P. Krishna Reddy, Jaideep Srivastava, and Tanmoy Chakraborty (eds.),
*Advances in Knowledge Discovery and Data Mining*, pp. 514–527, Cham,
Switzerland, 2021. Springer.
- Maggs et al. (2024)
Kelly Maggs, Celia Hacker, and Bastian Rieck.
Simplicial representation learning with neural $k$-forms.
In *International Conference on Learning Representations*, 2024.
URL [https://openreview.net/forum?id=Djw0XhjHZb](https://openreview.net/forum?id=Djw0XhjHZb).
- Maskey et al. (2022)
Sohir Maskey, Ali Parviz, Maximilian Thiessen, Hannes Stärk, Ylli Sadikaj,
and Haggai Maron.
Generalized laplacian positional encoding for graph representation
learning.
*arXiv preprint arXiv:2210.15956*, 2022.
- Morris et al. (2020)
Christopher Morris, Nils M Kriege, Franka Bause, Kristian Kersting, Petra
Mutzel, and Marion Neumann.
TUDataset: A collection of benchmark datasets for learning with
graphs.
*arXiv preprint arXiv:2007.08663*, 2020.
- Papamarkou et al. (2024)
Theodore Papamarkou, Tolga Birdal, Michael Bronstein, Gunnar Carlsson, Justin
Curry, Yue Gao, Mustafa Hajij, Roland Kwitt, Pietro Liò, Paolo Di Lorenzo,
Vasileios Maroulas, Nina Miolane, Farzana Nasrin, Karthikeyan Natesan
Ramamurthy, Bastian Rieck, Simone Scardapane, Michael T. Schaub, Petar
Veličković, Bei Wang, Yusu Wang, Guo-Wei Wei, and Ghada Zamzmi.
Position: Topological deep learning is the new frontier for
relational learning.
In Ruslan Salakhutdinov, Zico Kolter, Katherine Heller, Adrian
Weller, Nuria Oliver, Jonathan Scarlett, and Felix Berkenkamp (eds.),
*Proceedings of the 41st International Conference on Machine Learning*,
volume 235 of *Proceedings of Machine Learning Research*, pp. 39529–39555. PMLR, 2024.
- Rampášek et al. (2022)
Ladislav Rampášek, Michael Galkin, Vijay Prakash Dwivedi, Anh Tuan
Luu, Guy Wolf, and Dominique Beaini.
Recipe for a general, powerful, scalable graph transformer.
*Advances in Neural Information Processing Systems*,
35:14501–14515, 2022.
- Röell & Rieck (2024)
Ernst Röell and Bastian Rieck.
Differentiable Euler characteristic transforms for shape
classification.
In *International Conference on Learning Representations*, 2024.
URL [https://openreview.net/forum?id=MO632iPq3I](https://openreview.net/forum?id=MO632iPq3I).
- Rusch et al. (2023)
T Konstantin Rusch, Michael M Bronstein, and Siddhartha Mishra.
A survey on oversmoothing in graph neural networks.
*arXiv preprint arXiv:2303.10993*, 2023.
- Turner et al. (2014)
Katharine Turner, Sayan Mukherjee, and Doug M Boyer.
Persistent homology transform for modeling shapes and surfaces.
*Information and Inference: A Journal of the IMA*, 3(4):310–344, 2014.
- Vaswani et al. (2017)
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones,
Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin.
Attention is all you need.
*Advances in neural information processing systems*, 30, 2017.
- Veličković et al. (2018)
Petar Veličković, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro
Liò, and Yoshua Bengio.
Graph attention networks.
In *International Conference on Learning Representations*, 2018.
URL [https://openreview.net/forum?id=rJXMpikCZ](https://openreview.net/forum?id=rJXMpikCZ).
- Verma et al. (2024)
Yogesh Verma, Amauri H Souza, and Vikas Garg.
Topological neural networks go persistent, equivariant, and
continuous.
In Ruslan Salakhutdinov, Zico Kolter, Katherine Heller, Adrian
Weller, Nuria Oliver, Jonathan Scarlett, and Felix Berkenkamp (eds.),
*Proceedings of the 41st International Conference on Machine Learning*,
volume 235 of *Proceedings of Machine Learning Research*, pp. 49388–49407. PMLR, 2024.
- Verma et al. (2025)
Yogesh Verma, Amauri H Souza, and Vikas K Garg.
Positional encoding meets persistent homology on graphs.
In *Proceedings of the 42nd International Conference on Machine
Learning*, Proceedings of Machine Learning Research. PMLR, 2025.
- von Rohrscheidt & Rieck (2025)
Julius von Rohrscheidt and Bastian Rieck.
Diss-l-ECT: Dissecting graph data with local Euler characteristic
transforms.
In *Proceedings of the 42nd International Conference on Machine
Learning*, Proceedings of Machine Learning Research. PMLR, 2025.
- Wu et al. (2018)
Zhenqin Wu, Bharath Ramsundar, Evan N Feinberg, Joseph Gomes, Caleb Geniesse,
Aneesh S Pappu, Karl Leswing, and Vijay Pande.
MoleculeNet: A benchmark for molecular machine learning.
*Chemical science*, 9(2):513–530, 2018.
- Xu et al. (2019)
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](https://openreview.net/forum?id=ryGs6iA5Km).
- Zaheer et al. (2017)
Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Russ R
Salakhutdinov, and Alexander J Smola.
Deep sets.
In I. Guyon, U. Von Luxburg, S. Bengio, H. Wallach, R. Fergus,
S. Vishwanathan, and R. Garnett (eds.), *Advances in Neural Information
Processing Systems*, volume 30. Curran Associates, Inc., 2017.
- Zhang et al. (2023)
Xu Zhang, Yonghui Xu, Wei He, Wei Guo, and Lizhen Cui.
A comprehensive review of the oversmoothing in graph neural networks.
In *CCF Conference on Computer Supported Cooperative Work and
Social Computing*, pp. 451–465. Springer, 2023.

## Appendix

## Appendix A Results for the Alchemy and HIV datasets

Figure: GCN
Refer to caption: images/gcn_alchemy.png

## Appendix B Validation metrics

Figure: Validation Loss
Refer to caption: images/syn-loss_.png

Figure: Letter High
Refer to caption: images/high-curve_.png

## Appendix C Additional experiments

**Table 5: Accuracy results for all real-world datasets when varying the strategy of the LEAP PE with fixed and learnable directions for different models. The backbone architectures have around 4K parameters and we show the additional parameters each positional encoding introduces.**
|  |  | COX2 | BZR | DHFR | Letter-H | Letter-M | Letter-L | Fingerprint |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Model | Proj. Method | Parameters | LEAP-F | LEAP-L | LEAP-F | LEAP-L | LEAP-F | LEAP-L | LEAP-F | LEAP-L | LEAP-F | LEAP-L | LEAP-F | LEAP-L | LEAP-F | LEAP-L |
| GCN | Linear | 4K+2.5K | $79.2$ p m 0.6 | $79.4$ p m 1.0 | $78.8$ p m 0.6 | $82.5$ p m 2.0 | $70.9$ p m 3.2 | $74.9$ p m 4.0 | $72.2$ p m 3.3 | $74.2$ p m 1.5 | $82.8$ p m 1.4 | $83.6$ p m 1.3 | $95.2$ p m 0.9 | $96.0$ p m 0.9 | $55.6$ p m 1.1 | $54.7$ p m 1.5 |
| Attn | 4K+5K | $78.4$ p m 1.3 | $79.0$ p m 0.9 | $81.7$ p m 2.8 | $82.5$ p m 1.6 | $74.1$ p m 5.2 | $77.3$ p m 4.1 | $59.8$ p m 2.8 | $62.7$ p m 2.6 | $74.4$ p m 1.5 | $73.9$ p m 4.6 | $92.3$ p m 1.3 | $94.5$ p m 1.4 | $53.0$ p m 1.9 | $54.4$ p m 1.2 |  |
| Attn PE | 4K+5K | $78.2$ p m 1.2 | $78.8$ p m 1.3 | $82.5$ p m 2.4 | $82.5$ p m 3.1 | $73.2$ p m 3.7 | $77.6$ p m 2.8 | $67.2$ p m 1.5 | $68.6$ p m 1.8 | $82.0$ p m 0.8 | $82.9$ p m 2.2 | $95.8$ p m 1.1 | $94.7$ p m 1.6 | $54.1$ p m 1.3 | $55.1$ p m 1.2 |  |
| DeepSets | 4K+.5K | $78.2$ p m 0.6 | $79.0$ p m 1.2 | $79.0$ p m 1.2 | $81.7$ p m 3.5 | $71.2$ p m 2.6 | $73.3$ p m 3.6 | $59.2$ p m 1.9 | $63.4$ p m 2.1 | $72.4$ p m 0.6 | $76.0$ p m 1.1 | $91.4$ p m 1.8 | $92.0$ p m 0.6 | $52.3$ p m 1.3 | $54.1$ p m 1.3 |  |
| 1D Conv | 4K+.9K | $78.0$ p m 1.2 | $79.2$ p m 2.0 | $79.8$ p m 1.9 | $82.5$ p m 2.7 | $71.7$ p m 1.2 | $76.7$ p m 3.4 | $66.4$ p m 2.8 | $63.1$ p m 3.2 | $81.6$ p m 1.5 | $81.7$ p m 3.5 | $94.2$ p m 1.5 | $93.4$ p m 1.4 | $55.6$ p m 1.1 | $54.0$ p m 2.2 |  |
| GAT | Linear | 4K+2.5K | $78.4$ p m 1.2 | $79.7$ p m 2.0 | $79.3$ p m 1.8 | $81.7$ p m 2.4 | $75.7$ p m 3.0 | $76.3$ p m 2.2 | $70.2$ p m 2.2 | $73.5$ p m 2.1 | $82.4$ p m 2.3 | $82.4$ p m 1.6 | $95.8$ p m 0.8 | $95.1$ p m 0.9 | $55.1$ p m 0.6 | $54.8$ p m 2.1 |
| Attn | 4K+5K | $78.4$ p m 0.5 | $78.8$ p m 0.8 | $82.0$ p m 3.4 | $82.2$ p m 2.1 | $74.9$ p m 3.1 | $73.3$ p m 2.8 | $62.0$ p m 1.2 | $62.9$ p m 3.1 | $75.0$ p m 2.1 | $79.7$ p m 1.4 | $94.4$ p m 0.1 | $93.4$ p m 1.0 | $52.0$ p m 1.3 | $53.5$ p m 1.5 |  |
| Attn PE | 4K+5K | $78.8$ p m 0.8 | $80.1$ p m 2.2 | $82.0$ p m 3.2 | $79.5$ p m 0.7 | $73.2$ p m 3.1 | $75.9$ p m 5.8 | $66.7$ p m 2.0 | $65.0$ p m 3.5 | $83.2$ p m 1.1 | $79.3$ p m 2.4 | $94.0$ p m 1.3 | $95.1$ p m 1.1 | $54.5$ p m 1.8 | $54.5$ p m 1.8 |  |
| DeepSets | 4K+.5K | $79.2$ p m 1.6 | $79.7$ p m 1.8 | $81.2$ p m 2.0 | $82.7$ p m 4.7 | $71.2$ p m 4.1 | $76.5$ p m 3.8 | $58.8$ p m 2.6 | $56.4$ p m 4.3 | $75.4$ p m 3.1 | $76.6$ p m 2.3 | $94.6$ p m 1.4 | $93.1$ p m 1.3 | $52.9$ p m 2.2 | $51.0$ p m 1.1 |  |
| 1D Conv | 4K+.9K | $78.4$ p m 0.9 | $78.6$ p m 1.7 | $81.7$ p m 4.0 | $83.7$ p m 2.9 | $70.6$ p m 2.3 | $75.7$ p m 1.5 | $67.3$ p m 2.0 | $68.1$ p m 1.3 | $80.9$ p m 1.3 | $80.5$ p m 2.8 | $93.6$ p m 2.0 | $95.2$ p m 0.9 | $54.8$ p m 1.5 | $54.9$ p m 0.7 |  |
| NoMP | Linear | 4K+2.5K | $79.0$ p m 0.6 | $78.6$ p m 0.8 | $83.2$ p m 1.7 | $84.7$ p m 2.7 | $74.3$ p m 6.1 | $74.9$ p m 3.3 | $79.5$ p m 1.2 | $79.4$ p m 1.1 | $86.0$ p m 2.2 | $85.4$ p m 1.5 | $96.7$ p m 0.8 | $96.4$ p m 0.7 | $55.7$ p m 1.1 | $56.3$ p m 1.4 |
| Attn | 4K+5K | $78.2$ p m 0.5 | $78.2$ p m 0.5 | $81.7$ p m 2.8 | $79.0$ p m 0.9 | $68.3$ p m 5.7 | $71.7$ p m 4.1 | $79.0$ p m 1.8 | $81.3$ p m 1.9 | $84.8$ p m 0.9 | $86.5$ p m 2.6 | $96.1$ p m 0.6 | $97.2$ p m 0.8 | $53.8$ p m 0.7 | $54.8$ p m 1.2 |  |
| Attn PE | 4K+5K | $78.4$ p m 0.4 | $77.7$ p m 1.5 | $78.8$ p m 0.6 | $78.8$ p m 0.6 | $64.2$ p m 4.8 | $72.1$ p m 3.7 | $81.3$ p m 1.9 | $80.6$ p m 3.6 | $88.0$ p m 1.9 | $86.5$ p m 2.2 | $96.3$ p m 0.8 | $96.2$ p m 1.2 | $54.8$ p m 1.4 | $55.3$ p m 1.1 |  |
| DeepSets | 4K+.5K | $78.4$ p m 0.8 | $78.0$ p m 0.5 | $83.2$ p m 2.1 | $82.0$ p m 2.8 | $69.5$ p m 3.0 | $72.6$ p m 3.6 | $78.0$ p m 2.0 | $79.2$ p m 1.9 | $86.0$ p m 2.2 | $87.5$ p m 2.0 | $96.3$ p m 0.6 | $96.6$ p m 0.8 | $54.0$ p m 0.4 | $54.3$ p m 1.0 |  |
| 1D Conv | 4K+.9K | $78.0$ p m 1.9 | $78.1$ p m 1.1 | $81.0$ p m 1.7 | $79.3$ p m 1.8 | $71.6$ p m 3.2 | $75.7$ p m 2.7 | $81.1$ p m 0.9 | $81.6$ p m 1.9 | $87.0$ p m 2.0 | $88.5$ p m 2.5 | $97.2$ p m 0.3 | $98.0$ p m 0.4 | $54.5$ p m 1.0 | $54.1$ p m 0.4 |  |

Figure: Letter High
Refer to caption: images/ablations_fixed_high.png

**Table 6: We provide a comparison with DECT (Röell & Rieck, 2024). DECT summarizes the graph with a single global ECT and subsequently applies a convolutional neural network for the classification. We compare our method with two variants of DECT, one with 4K parameters and one with 65K parameters. The parameter count in LEAP ranges from 1K to 5K and therefore the comparison with DECT (4K) would be the most appropriate, although we outperform both variants on most datasets.**
| Model | COX2 | BZR | DHFR | Letter-H | Letter-M | Letter-L |
| --- | --- | --- | --- | --- | --- | --- |
| DECT (4K) | $70.4$ p m 0.9 | $81.8$ p m 3.2 | $67.9$ p m 5.0 | $63.8$ p m 6.0 | $76.2$ p m 4.8 | $91.5$ p m 2.1 |
| DECT (65K) | $74.6$ p m 4.5 | $84.3$ p m 6.1 | $72.9$ p m 1.6 | $85.4$ p m 1.3 | $86.3$ p m 2.0 | $96.8$ p m 1.2 |
| LEAP-L (GCN) | $79.4$ p m 1.0 | $82.5$ p m 1.6 | $77.6$ p m 2.8 | $74.2$ p m 1.5 | $83.6$ p m 1.3 | $96.0$ p m 0.9 |
| LEAP-L (GAT) | $80.1$ p m 2.2 | $83.7$ p m 2.9 | $76.5$ p m 3.8 | $73.5$ p m 2.1 | $82.4$ p m 1.6 | $95.2$ p m 0.9 |
| LEAP-L (NoMP) | $78.6$ p m 0.8 | $84.7$ p m 2.7 | $75.7$ p m 2.7 | $81.6$ p m 1.9 | $88.5$ p m 2.5 | $98.0$ p m 0.4 |

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 6
presentation: 3
questions: Q1: On the HIV dataset, the locally encoded LEAP underperforms the globally informed LaPE. Could the authors elaborate on why global structural information is crucial for this task?

Q2: The injectivity of the Euler Characteristic Transform underpins its discriminative power, yet LEAP employs a differentiable local approximation. Do the authors have theoretical or empirical evidence that this approximation preserves key topological information compared with the exact, global ECT?

Q3: Is LEAP applicable to geometric graphs? If so, how does it leverage spatial coordinates or geometric relationships within the ℓ-ECT framework?
soundness: 2
strengths: S1: The paper proposes an end-to-end trainable framework for encoding positional information, eliminating the need for static or precomputed preprocessing.

S2: The experimental setup is well-structured, evaluating three mainstream GNN architectures across multiple datasets, including both synthetic and real-world benchmarks. 

S3: Ablation studies demonstrate LEAP’s robustness to key hyperparameters and locality configurations. Moreover, the five projection strategies showcase LEAP’s adaptability to diverse model architectures and task requirements.
summary: This paper introduces LEAP, an end-to-end trainable local structural positional encoding that integrates geometric and topological information via the local Euler Characteristic Transform (ℓ-ECT). LEAP computes node-level embeddings by extracting m-hop neighborhoods, normalizing local features, applying a differentiable ℓ-ECT, and projecting the resulting matrix into a compact representation through learnable modules (e.g., linear layers, 1D convolutions, or DeepSets). Two variants are proposed: LEAP-F, which uses fixed ECT directions, and LEAP-L, which learns them during training. Extensive experiments on both synthetic and real-world datasets, using three GNN architectures, confirm that LEAP substantially enhances graph representation learning.
weaknesses: W1: Although the paper discusses LEAP’s robustness to hyperparameters (e.g., number of directions, thresholds), it omits computational efficiency analysis.

W2: Since no single projection strategy yields the best results across all tasks, do the authors have heuristic or data-driven guidelines for choosing among them

W3: Theoretical analysis and justification are insufficient, which is critical for this method-oriented paper.

---

confidence: 2
contribution: 2
initial_rating: 4
presentation: 3
questions: The ablation study (Table 2 ) shows that 1-hop neighborhoods perform better than 2-hop or a 1,2-hop combination. This seems counter-intuitive to the MPNN notion that larger receptive fields are better. Why is 1-hop sufficient?

How does LEAP perform on very large graphs?
soundness: 3
strengths: (1) LEAP is the first work to integrate the local ECT into GNNs in an end-to-end trainable manner, combining geometric and topological insights.

(2) The authors evaluate their method on synthetic data, small molecules, image graphs, and large-scale quantum chemistry datasets, showing consistent improvements. The synthetic task clearly demonstrates LEAP’s ability to classify graphs based solely on structural information, highlighting limitations of standard MPNNs.

(3) The paper includes thorough ablation studies on various aspects (Projection strategies, Locality, PE dimension, and DECT hyperparameters) of LEAP, strengthening its conclusions.
summary: The paper proposes LEAP, a learnable positional encoding for graphs based on the local Euler Characteristic Transform ($l$-ECT), which integrates both geometric and topological information and supports end-to-end training. The authors validate LEAP on synthetic tasks and multiple real-world graph datasets, demonstrating its ability to capture structural information even when node features are non-informative.
weaknesses: (1) As the authors acknowledge in the limitations, LEAP is not a purely structural PE. It requires node features $x(v)$ to compute the ECT. While the synthetic experiment shows LEAP works even with uninformative features, it is unclear how, or if, LEAP would be applied to graphs without any node features (e.g., graphs represented only by an adjacency matrix).

(2) LEAP introduces more hyperparameters (e.g., number of directions, smoothing, discretization steps) compared to LaPE or RWPE.

(3) Although not analyzed in depth, computing ECT for m-hop subgraphs for every node could be expensive for large graphs.

---

confidence: 3
contribution: 2
initial_rating: 4
presentation: 3
questions: 1. Since LEAP is intrinsically local, have you considered augmenting it with a complementary global encoding? Could LEAP be combined with LaPE without redundancy?
2. What is the computational overhead per graph and per layer when incorporating LEAP? How does it scale with graph size and number of directions?
soundness: 2
strengths: 1. The use of local, differentiable Euler characteristic transforms as graph positional encoding is an interesting new direction that meaningfully blends geometric and topological features.
2. The paper clearly explains the limitations of pure message passing networks and why positional encoding is useful.
3. The learnable direction variants of LEAP show thoughtful design toward practical applicability.
summary: This paper proposes LEAP, a learnable graph positional encoding method based on a local Euler Characteristic Transform (ℓ-ECT). The key idea is to compute differentiable, direction-dependent topology-aware signatures localized around each node and incorporate them as positional embeddings in standard GNN architectures. By leveraging both geometric and topological structure, LEAP aims to address limitations of message passing GNNs that struggle to capture higher-order structural patterns. The authors evaluate the method on synthetic and real-world graph classification datasets, comparing to standard positional encodings such as RWPE and Laplacian-based LaPE. Results indicate that LEAP improves performance in many settings, particularly when used with architectures that are otherwise limited in structural awareness.
weaknesses: 1. While LEAP is motivated as addressing expressivity limits of MPNNs, the paper does not provide formal analysis or guarantees regarding what structural distinctions LEAP can or cannot capture. The argument remains primarily empirical.
2. While LEAP performs well in several TU datasets, its benefits diminish or disappear on datasets where global structure is more important (e.g., HIV), where LaPE performs best. This suggests that LEAP may be inherently limited in capturing global structural contexts, which should be more explicitly acknowledged or explored.

---

confidence: 4
contribution: 2
initial_rating: 6
presentation: 4
questions: Major remarks: 

i) It is unfortunate that the word "projection" is used in two different contexts: former concerning the definition of ECT, Eq. (4), latter concerning the $\phi$ map at l.198. Moreover, this word plays a role in your acronym and it is quite clear that you refer to the second projection ($\phi$) there but a few words about it would be appreciated. 

ii) At line 225 you introduce the notion of *valid graph embedding*. It would be wise to recall the reader what it means.

iii) The experiments of the synthetic dataset are the only ones not being very convincing. I mean: what happens when you provide GCN/GAT with LaPE or RWPE? Isn't the prediction score equal to 1? Even if it were the case it would not be an issue, in my view, since in the rest of the section, by the way, you beat the state-of-the-art.

iv) Here's the weakest point of the paper in my view. There is a number of message passing architectures known to be more expressive w.r.t. GCNs. The first and maybe most important I can think of is graphs isomorphism networks (GINs, [1]). Including them in your Table 4 would turn your paper into a master  piece.  
 
v) At l. 355 I read: "An interesting observation from Table 4 ... ". I think you were too modest in your commentary! What I see in Table 4 is that on 5 columns over 7 the best accuracy score is obtained by a neural architecture **not** being a GNN, provided that it is equipped with LEAP-L. Did about Alchemy and HIV datasets? Did you test NoMP on them?

Minor remarks: 

i) At line 239, you need a space between *to* and $|\\Theta |$  
ii) Line 248: *rojection* -> *projection*
soundness: 3
strengths: This paper is really well written, clear and concise.  The experimental setup is solid and the results are impressive (more comments later), however I would say the contribution is just "fair" since local and global ECT descriptors already existed. However, I think that this paper has the potential to be accepted at ICLR, so I am **temporarily** ranking it with a 6, but I am ready to raise my note to 8 after the discussion, provided some key points are discussed/addressed.
summary: Building upon the local Euler Characteristic Transform ($\ell$-ECT), this paper introduces a new class of learnable *local strucutral encodings* (LSE) that can be integrated in any GNN architecture. To be precise, the main novelty is that such structural encodings are made learnable, since they were already adopted as static descriptors in another work, although very recent. Another novelty lies into a new "projection" layer in the proposed neural architecture, allowing one to reduce a matrix containing the differentiable approximations of $\ell$-ECT, one per vertex, into a final vector: the positional encoding for that vertex. The approach is extremely versatile and the experimental section clearly shows that i) the proposed LSE allows standard GNNs to improve their performance in a variety of tasks and ii) learning the LSEs further increase the improvement and iii)  the choice of the hyper-parameters (e.g. number of directions, time grids) in not constraining, meaning that different choices still lead to good results, except for the hop's ray, in this case the smaller the better.
weaknesses: A few points deserves to be discussed and/or presented differently. One major drawback, discussed below, and this is the only reason why I do not immediately rate this paper with a 8.


Decision: Accept (Poster)