Original: R ETHINKING THE E XPRESSIVE P OWER OF GNN S VIA G RAPH B ICONNECTIVITY
Revised: R ETHINKING THE E XPRESSIVE P OWER OF GNN S VIA G RAPH B ICONNECTIVITY

Original: Anonymous authors

Original: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Designing expressive Graph Neural Networks (GNNs) is a central topic in learning graph-structured data.
Revised: Designing expressive Graph Neural Networks (GNNs) is a central topic in learning graph-structured data.

Original: While numerous approaches have been proposed to improve GNNs w.r.t. the Weisfeiler-Lehman (WL) test, for most of them, there is still a lack of deep understanding of what additional power they can systematically and provably gain.
Revised: While numerous approaches have been proposed to improve GNNs in terms of the Weisfeiler-Lehman (WL) test, generally there is still a lack of deep understanding of what additional power they can systematically and provably gain.

Original: In this paper, we take a fundamentally different perspective to study the expressive power of GNNs beyond the WL test.
Revised: In this paper, we take a fundamentally different perspective to study the expressive power of GNNs beyond the WL test.

Original: Specifically, we introduce a novel class of expressivity metrics via graph biconnectivity and highlight their importance in both theory and practice.
Revised: Specifically, we introduce a novel class of expressivity metrics via graph biconnectivity and highlight their importance in both theory and practice.

Original: As biconnectivity can be easily calculated using simple algorithms that have linear computational costs, it is natural to expect that popular GNNs can learn it easily as well.
Revised: As biconnectivity can be easily calculated using simple algorithms that have linear computational costs, it is natural to expect that popular GNNs can learn it easily as well.

Original: However, after a thorough review of prior GNN architectures, we surprisingly find that most of them are not expressive for any of these metrics.
Revised: However, after a thorough review of prior GNN architectures, we surprisingly find that most of them are not expressive for any of these metrics.

Original: The only exception is the ESAN framework (Bevilacqua et al., 2022), for which we give a theoretical justification of its power.
Revised: The only exception is the ESAN framework (Bevilacqua et al., 2022), for which we give a theoretical justification of its power.

Original: We proceed to introduce a principled and more efficient approach, called the Generalized Distance Weisfeiler-Lehman (GD-WL), which is provably expressive for all biconnectivity metrics.
Revised: We proceed to introduce a principled and more efficient approach, called the Generalized Distance Weisfeiler-Lehman (GD-WL), which is provably expressive for all biconnectivity metrics.

Original: Practically, we show GD-WL can be implemented by a
Revised: Practically, we show GD-WL can be implemented by a

Original: Transformer-like architecture that preserves expressiveness and enjoys full parallelizability.
Revised: Transformer-like architecture that preserves expressiveness and enjoys full parallelizability.

Original: A set of experiments on both synthetic and real datasets demonstrates that our approach can consistently outperform prior GNN architectures.
Revised: A set of experiments on both synthetic and real datasets demonstrates that our approach can consistently outperform prior GNN architectures.

Original:  I NTRODUCTION 
Revised:  I NTRODUCTION Graph

Original: Graph neural networks (GNNs) have recently become the dominant approach for graph representation learning.
Revised: neural networks (GNNs) have recently become the dominant approach for graph representation learning.

Original: Among numerous architectures, message-passing neural networks (MPNNs) are arguably the most popular design paradigm and have achieved great success in various fields (Gilmer et al., 2017; Hamilton et al., 2017; Kipf & Welling, 2017;
Revised: Among numerous architectures, message-passing neural networks (MPNNs) are arguably the most popular design paradigm and have achieved great success in various fields (Gilmer et al., 2017; Hamilton et al., 2017; Kipf & Welling, 2017;

Original: Veli ˇ ckovi ´ c et al., 2018).
Revised: Veli ˇ ckovi ´ c et al., 2018).

Original: However, one major drawback of MPNNs lies in the limited expressiveness: as pointed out by Xu et al.
Revised: However, one major drawback of MPNNs lies in the limited expressiveness: as pointed out by Xu et al.

Original: Morris et al.
Revised: Morris et al.

Original: (2019), they can never be more powerful than the classic 1-dimensional WeisfeilerLehman (1-WL) test in distinguishing non-isomorphic graphs (Weisfeiler & Leman, 1968).
Revised: (2019), they can never be more powerful than the classic 1-dimensional WeisfeilerLehman (1-WL) test in distinguishing non-isomorphic graphs (Weisfeiler & Leman, 1968).

Original: This inspired a variety of works to design provably more powerful GNNs that go beyond the 1-WL test.
Revised: This inspired a variety of works to design provably more powerful GNNs that go beyond the 1-WL test.

Original: One line of subsequent works aimed to propose GNNs that match the higher-order WL variants (Morris et al., 2019; 2020; Maron et al., 2019c;a; Geerts & Reutter, 2022).
Revised: One line of subsequent works aimed to propose GNNs that match the higher-order WL variants (Morris et al., 2019; 2020; Maron et al., 2019c;a; Geerts & Reutter, 2022).

Original: While being highly expressive, such an approach suffers from severe computation/memory costs.
Revised: While being highly expressive, such an approach suffers from severe computation/memory costs.

Original: Moreover, there have been concerns about whether the achieved expressiveness is necessary for real-world tasks (Veliˇckovi´c, 2022).
Revised: Moreover, there have been concerns about whether the achieved expressiveness is necessary for real-world tasks (Veliˇckovi´c, 2022).

Original: In light of this, other recent works sought to develop new GNN architectures with improved expressiveness while still keeping the message-passing framework for efficiency (Bouritsas et al., 2022; Bodnar et al.
Revised: In light of this, other recent works sought to develop new GNN architectures with improved expressiveness while still keeping the message-passing framework for efficiency (Bouritsas et al., 2022; Bodnar et al.

Original: , 2021b;a; Bevilacqua et al., 2022; Wijesinghe & Wang, 2022, and see Appendix A for more recent advances).
Revised: , 2021b;a; Bevilacqua et al., 2022; Wijesinghe & Wang, 2022, and see Appendix A for more recent advances).

Original: However, most of these works mainly justify their expressiveness by giving toy examples where WL algorithms fail to distinguish, e.g., by focusing on regular graphs.
Revised: However, most of these works mainly justify their expressiveness by giving toy examples where WL algorithms fail to distinguish, e.g., by focusing on regular graphs.

Original: On the theoretical side, it is quite unclear what additional power they can systematically and provably gain.
Revised: On the theoretical side, it is quite unclear what additional power they can systematically and provably gain.

Original: More fundamentally, to the best of our knowledge (see Appendix D.1), there is still a lack of principled and convincing metrics beyond the WL hierarchy to formally measure the expressive power and to guide the design of provably betterGNN architectures.
Revised: More fundamentally, to the best of our knowledge (see Appendix D.1), there is still a lack of principled and convincing metrics beyond the WL hierarchy to formally measure the expressive power and to guide the design of provably better

Original: In this paper, we systematically study the problem of designing expressive GNNs from a novel perspective of graph biconnectivity .

Original: Biconnectivity has long been a central topic in graph theory (Bollob´as, 1998).

Original: It comprises a series of important concepts such as cut vertex (articulation point), cut edge (bridge), biconnected component, and block cut tree (see Section 2 for formal definitions).

Original: L
Revised: L

Original: G
Revised: G

Original: C
Revised: C

Original: E
Revised: E

Original: F
Revised: F

Original: H
Revised: H

Original: D
Revised: D

Original: J
Revised: J

Original: I
Revised: I

Original: N
Revised: N

Original: B
Revised: B

Original: A
Revised: A

Original: M K {G} {H} {A,B,C} {J,K,L,M,N} {D,E,F,I}
Revised: M K {G} {H} {A,B,C} {J,K,L,M,N} {D,E,F,I}

Original: C
Revised: C

Original: F D
Revised: F D

Original: J {A,B,C} {D,E,F,I} {J,K,L} {J,M,N} {F,G} {F,H} {I,J}
Revised: J {A,B,C} {D,E,F,I} {J,K,L} {J,M,N} {F,G} {F,H} {I,J}

Original: I {C,D}
Revised: I {C,D}

Original: [Figure]
Revised: [Figure]

Revised: In this paper, we systematically study the problem of designing expressive GNNs from a novel perspective of graph biconnectivity .

Revised: Biconnectivity has long been a central topic in graph theory (Bollob´as, 1998).

Revised: It comprises a series of important concepts such as cut vertex (articulation point), cut edge (bridge), biconnected component, and block cut tree (see Section 2 for formal definitions).

Original: Intuitively, biconnectivity provides a structural description of a graph by decomposing it into disjoint sub-components and linking them via cut vertices/edges to form a tree structure (cf.
Revised: Intuitively, biconnectivity provides a structural description of a graph by decomposing it into disjoint sub-components and linking them via cut vertices/edges to form a tree structure (cf.

Original: Figure 1(b,c)).
Revised: Figure 1(b,c)).

Original: As can be seen, biconnectivity purely captures the intrinsic structure of a graph.
Revised: As can be seen, biconnectivity purely captures the intrinsic structure of a graph.

Original: The significance of graph biconnectivity can be reflected in various aspects.
Revised: The significance of graph biconnectivity can be reflected in various aspects.

Original: Firstly , from a theoretical point of view, it is a basic graph property and is linked to many fundamental topics in graph theory, ranging from path-related problems to network flow (Granot & Veinott Jr, 1985) and spanning trees (Kapoor & Ramesh, 1995), and is highly relevant to planar graph isomorphism (Hopcroft & Tarjan, 1972).
Revised: Firstly , from a theoretical point of view, it is a basic graph property and is linked to many fundamental topics in graph theory, ranging from path-related problems to network flow (Granot & Veinott Jr, 1985) and spanning trees (Kapoor & Ramesh, 1995), and is highly relevant to planar graph isomorphism (Hopcroft & Tarjan, 1972).

Original: Secondly , from a practical point of view, cut vertices/edges have substantial values in many real applications.
Revised: Secondly , from a practical point of view, cut vertices/edges have substantial values in many real applications.

Original: For example, chemical reactions are highly related to edge-biconnectivity of the molecule graph, where the breakage of molecular bonds usually occurs at the cut edges and each biconnected component often remains unchanged after the reaction.
Revised: For example, chemical reactions are highly related to edge-biconnectivity of the molecule graph, where the breakage of molecular bonds usually occurs at the cut edges and each biconnected component often remains unchanged after the reaction.

Original: As another example, social networks are related to vertex-biconnectivity, where cut vertices play an important role in linking between different groups of people (biconnected components).
Revised: As another example, social networks are related to vertex-biconnectivity, where cut vertices play an important role in linking between different groups of people (biconnected components).

Original: Finally , from a computational point of view, the problems related to biconnectivity (e.g., finding cut vertices/edges or constructing block cut trees) can all be efficiently solved using classic algorithms (Tarjan, 1972), with a computation complexity equal to graph size (which is the same as an MPNN).
Revised: Finally , from a computational point of view, the problems related to biconnectivity (e.g., finding cut vertices/edges or constructing block cut trees) can all be efficiently solved using classic algorithms (Tarjan, 1972), with a computation complexity equal to graph size (which is the same as an MPNN).

Original: Therefore, one may naturally expect that popular GNNs should be able to learn all things related to biconnectivity without difficulty.
Revised: Therefore, one may naturally expect that popular GNNs should be able to learn all things related to biconnectivity without difficulty.

Original: Unfortunately, we show this is not the case.
Revised: Unfortunately, we show this is not the case.

Original: After a thorough analysis of four classes of representative GNN architectures in literature (see Section 3.1), we find that surprisingly, none of them could even solve the easiest biconnectivity problem: to distinguish whether a graph has cut vertices/edges or not (corresponding to a graph-level binary classification).
Revised: After a thorough analysis of four classes of representative GNN architectures in literature (see Section 3.1), we find that surprisingly, none of them could even solve the easiest biconnectivity problem: to distinguish whether a graph has cut vertices/edges or not (corresponding to a graph-level binary classification).

Original: As a result, they obviously failed in the following harder tasks: (i) identifying all cut vertices (a node-level task); (ii) identifying all cut edges (an edge-level task); (iii) the graph-level task for general biconnectivity problems, e.g., distinguishing a pair of graphs that have non-isomorphic block cut trees.
Revised: As a result, they obviously failed in the following harder tasks: (i) identifying all cut vertices (a node-level task); (ii) identifying all cut edges (an edge-level task); (iii) the graph-level task for general biconnectivity problems, e.g., distinguishing a pair of graphs that have non-isomorphic block cut trees.

Original: This raises the following question: can we design GNNs with provable expressiveness for biconnectivity problems?
Revised: This raises the following question: can we design GNNs with provable expressiveness for biconnectivity problems?

Original: We first give an affirmative answer to the above question.
Revised: We first give an affirmative answer to the above question.

Original: By conducting a deep analysis of the recently proposed Equivariant Subgraph Aggregation Network (ESAN) (Bevilacqua et al., 2022), we prove that the DSS-WL algorithm with node marking policy can precisely identify both cut vertices and cut edges.
Revised: By conducting a deep analysis of the recently proposed Equivariant Subgraph Aggregation Network (ESAN) (Bevilacqua et al., 2022), we prove that the DSS-WL algorithm with node marking policy can precisely identify both cut vertices and cut edges.

Original: This provides a new understanding as well as a strong theoretical justification for the expressive power of DSS-WL and its recent extensions (Frasca et al., 2022).
Revised: This provides a new understanding as well as a strong theoretical justification for the expressive power of DSS-WL and its recent extensions (Frasca et al., 2022).

Original: Furthermore, we give a fine-grained analysis of several key factors in the framework, such as the graph generation policy and the aggregation scheme, by showing that neither (i) the ego-network policy without marking nor (ii) a variant of the weaker DS-WL algorithm can identify cut vertices.
Revised: Furthermore, we give a fine-grained analysis of several key factors in the framework, such as the graph generation policy and the aggregation scheme, by showing that neither (i) the ego-network policy without marking nor (ii) a variant of the weaker DS-WL algorithm can identify cut vertices.

Original: However, GNNs designed based on DSS-WL are usually sophisticated and suffer from high computation/memory costs.
Revised: However, GNNs designed based on DSS-WL are usually sophisticated and suffer from high computation/memory costs.

Original: The main contribution in this paper is then to give a principled and efficient way to design GNNs that are expressive for biconnectivity problems.
Revised: The main contribution in this paper is then to give a principled and efficient way to design GNNs that are expressive for biconnectivity problems.

Original: Targeting this question, we restart from the classic 1-WL algorithm and figure out a major weakness in distinguishing biconnectivity: the lack of distance information between nodes.
Revised: Targeting this question, we restart from the classic 1-WL algorithm and figure out a major weakness in distinguishing biconnectivity: the lack of distance information between nodes.

Original: Indeed, the importance of distance information is theoretically justified in our proof for analyzing the expressive power of DSS-WL.
Revised: Indeed, the importance of distance information is theoretically justified in our proof for analyzing the expressive power of DSS-WL.

Original: To this end, we introduce a novel color refinement framework, formalized as Generalized Distance
Revised: To this end, we introduce a novel color refinement framework, formalized as Generalized Distance

Original: Weisfeiler-Lehman (GD-WL), by directly encoding a general distance metric into the WL aggregation procedure.
Revised: Weisfeiler-Lehman (GD-WL), by directly encoding a general distance metric into the WL aggrega- [Table] tion procedure.

Original: We first prove that as a special case, the Shortest Path Distance WL (SPD-WL) is expressive for all edge-biconnectivity problems, thus providing a novel understanding of its empirical success.
Revised: We first prove that as a special case, the Shortest Path Distance WL (SPD-WL) is expressive for all edge-biconnectivity problems [Table] thus providing a novel understanding of its empirical success.

Original: However, it still cannot identify cut vertices.
Revised: However [Table] it still cannot identify cut vertices.

Original: We further suggest an alternative called the
Revised: We further suggest an alternative called the

Original: Resistance Distance WL (RD-WL) for vertex-biconnectivity.
Revised: Resistance Distance WL (RD-WL) for vertex-biconnectivity.

Original: To sum up, all biconnectivity problems can be provably solved within our proposed GD-WL framework.
Revised: To sum up, all biconnectivity problems can be provably solved within our proposed GD-WL framework

Original: [Table]
Revised: [Table]

Original: Practical Implementation .
Revised: Practical Implementation .

Original: The main advantage of GD-WL lies in its simplicity, efficiency and parallelizability .
Revised: The main advantage of GD-WL lies in its simplicity, efficiency and parallelizability .

Original: We show it can be easily implemented using a Transformer-like architecture by injecting the distance into Multi-head Attention (Vaswani et al., 2017), similar to Ying et al.
Revised: We show it can be easily implemented using a Transformer-like architecture by injecting the distance into Multi-head Attention (Vaswani et al., 2017), similar to Ying et al.

Original: (2021a)
Revised: (2021a).

Original: [Table] Importantly, we prove that the resulting Graph Transformer (called Graphormer-GD) is as expressive as GD-WL.
Revised: Importantly, we prove that the resulting Graph Transformer (called Graphormer-GD) is as expressive as GD-WL.

Original: This offers strong theoretical insights into the power and limits of Graph Transformers.
Revised: This offers strong theoretical insights into the power and limits of Graph Transformers.

Original: Empirically, we show Graphormer-GD not only achieves perfect accuracy in detecting cut vertices and cut edges, but also outperforms prior GNN achitectures on popular benchmark datasets.
Revised: Empirically, we show Graphormer-GD not only achieves perfect accuracy in detecting cut vertices and cut edges, but also outperforms prior GNN achitectures on popular benchmark datasets.

Original:  P RELIMINARY
Revised:  P RELIMINARY

Original: Notations .
Revised: Notations .

Original: We use { } to denote sets and use {{ }} to denote multisets.
Revised: We use { } to denote sets and use {{ }} to denote multisets.

Original: The cardinality of (multi)set
Revised: The cardinality of (multi)set

Original: S is denoted as |S| .
Revised: S is denoted as |S| .

Original: The index set is denoted as [ n ] := { 1 , · · · , n } .
Revised: The index set is denoted as [ n ] := { 1 , · · · , n } .

Original: Throughout this paper, we consider simple undirected graphs G
Revised: Throughout this paper, we consider simple undirected graphs G

Original: =
Revised: =

Original: ( V , E ) with no repeated edges or self-loops.
Revised: ( V , E ) with no repeated edges or self-loops.

Original: Therefore, each edge { u, v } ∈ E can be expressed as a set of two elements.
Revised: Therefore, each edge { u, v } ∈ E can be expressed as a set of two elements.

Original: For a node u ∈ V , denote its neighbors as N G ( u ) :
Revised: For a node u ∈ V , denote its neighbors as N G ( u ) :

Original: = { v ∈ V : { u, v } ∈ E} and denote its degree as deg G ( u ) :
Revised: = { v ∈ V : { u, v } ∈ E} and denote its degree as deg G ( u ) :

Original: = |N G ( u ) | .
Revised: = |N G ( u ) | .

Original: A path P = ( u 0 , · · · , u d ) is a tuple of nodes satisfying { u i − 1 , u i } ∈ E for all i ∈
Revised: A path P = ( u 0 , · · · , u d ) is a tuple of nodes satisfying { u i − 1 , u i } ∈ E for all i ∈

Original: [ d ] , and its length is denoted as | P | := d .
Revised: [ d ] , and its length is denoted as | P | := d .

Original: A path P is said to be simple if it does not go through a node more than once, i.e. u i ̸ =
Revised: A path P is said to be simple if it does not go through a node more than once, i.e. u i ̸ =

Original: u j for i ̸
Revised: u j for i ̸

Original: = j .
Revised: = j .

Original: The shortest path distance between two nodes u and v is denoted to be dis G ( u, v ) :
Revised: The shortest path distance between two nodes u and v is denoted to be dis G ( u, v ) :

Original: = min {| P | : P is a path from u to v } .
Revised: = min {| P | : P is a path from u to v } .

Original: The induced subgraph with vertex subset S ⊂ V is defined as G [ S ] = ( S , E S ) where E S :
Revised: The induced subgraph with vertex subset S ⊂ V is defined as G [ S ] = ( S , E S ) where E S :

Original: = {{ u, v } ∈ E : u, v ∈ S} .
Revised: = {{ u, v } ∈ E : u, v ∈ S} .

Original: We next introduce the concepts of connectivity, vertex-biconnectivity and edge-biconnectivity.
Revised: We next introduce the concepts of connectivity, vertex-biconnectivity and edge-biconnectivity.

Original: Definition 2.1.
Revised: Definition 2.1.

Original: ( Connectivity )
Revised: ( Connectivity )

Original: A graph G is connected if for any two nodes u, v ∈ V , there is a path from u to v .
Revised: A graph G is connected if for any two nodes u, v ∈ V , there is a path from u to v .

Original: A vertex set S ⊂ V is a connected component of G if G [ S ] is connected and for any proper superset T ⊋ S , G [ T ] is disconnected.
Revised: A vertex set S ⊂ V is a connected component of G if G [ S ] is connected and for any proper superset T ⊋ S , G [ T ] is disconnected.

Original: Denote CC( G ) as the set of all connected components, then CC( G ) forms a partition of the vertex set V .
Revised: Denote CC( G ) as the set of all connected components, then CC( G ) forms a partition of the vertex set V .

Original: Clearly, G is connected iff | CC( G ) | = 1 .
Revised: Clearly, G is connected iff | CC( G ) | = 1 .

Original: Definition 2.2.
Revised: Definition 2.2.

Original: ( Biconnectivity )
Revised: ( Biconnectivity )

Original: A node v ∈ V is a cut vertex (or articulation point ) of G if removing v increases the number of connected components, i.e., | CC( G [ V\{ v } ]) | >
Revised: A node v ∈ V is a cut vertex (or articulation point ) of G if removing v increases the number of connected components, i.e., | CC( G [ V\{ v } ]) | >

Original: | CC( G ) | .
Revised: | CC( G ) | .

Original: A graph is vertex-biconnected if it is connected and does not have any cut vertex.
Revised: A graph is vertex-biconnected if it is connected and does not have any cut vertex.

Original: A vertex set S ⊂ V is a vertex-biconnected component of G if G [ S ] is vertex-biconnected and for any proper superset T ⊋ S , G [ T ] is not vertex-biconnected.
Revised: A vertex set S ⊂ V is a vertex-biconnected component of G if G [ S ] is vertex-biconnected and for any proper superset T ⊋ S , G [ T ] is not vertex-biconnected.

Original: We can similarly define the concepts of cut edge (or bridge ) and edge-biconnected component (we omit them for brevity).
Revised: We can similarly define the concepts of cut edge (or bridge ) and edge-biconnected component (we omit them for brevity).

Original: Finally, denote BCC V ( G ) (resp.
Revised: Finally, denote BCC V ( G ) (resp.

Original: BCC E ( G ) ) as the set of all vertex-biconnected (resp.
Revised: BCC E ( G ) ) as the set of all vertex-biconnected (resp.

Original: edge-biconnected) components.
Revised: edge-biconnected) components.

Original: Two non-adjacent nodes u, v ∈ V are in the same vertex-biconnected component iff there are two paths from u to v that do not intersect (except at endpoints).
Revised: Two non-adjacent nodes u, v ∈ V are in the same vertex-biconnected component iff there are two paths from u to v that do not intersect (except at endpoints).

Original: Two nodes u, v are in the same edgebiconnected component iff there are two paths from u to v that do not share an edge.
Revised: Two nodes u, v are in the same edgebiconnected component iff there are two paths from u to v that do not share an edge.

Original: On the other hand, if two nodes are in different vertex/edge-biconnected components, any path between them must go through some cut vertex/edge.
Revised: On the other hand, if two nodes are in different vertex/edge-biconnected components, any path between them must go through some cut vertex/edge.

Original: Therefore, cut vertices/edges can be regarded as “hubs” in a graph that link different subgraphs into a whole.
Revised: Therefore, cut vertices/edges can be regarded as “hubs” in a graph that link different subgraphs into a whole.

Original: Furthermore, the link between cut vertices/edges and biconnected components forms a tree structure, which are called the block cut tree (cf.
Revised: Furthermore, the link between cut vertices/edges and biconnected components forms a tree structure, which are called the block cut tree (cf.

Original: Figure 1).
Revised: Figure 1).

Original: Definition 2.3.
Revised: Definition 2.3.

Original: ( Block cut-edge tree )
Revised: ( Block cut-edge tree )

Original: The block cut-edge tree of graph G =
Revised: The block cut-edge tree of graph G =

Original: ( V , E ) is defined as follows:
Revised: ( V , E ) is defined as follows:

Original: BCETree( G ) :
Revised: BCETree( G ) :

Original: = (BCC E ( G ) , E E ) , where
Revised: = (BCC E ( G ) , E E ) , where

Original: [Equation]
Revised: [Equation]

Original: Definition 2.4.
Revised: Definition 2.4.

Original: ( Block cut-vertex tree )
Revised: ( Block cut-vertex tree )

Original: The block cut-vertex tree of graph G =
Revised: The block cut-vertex tree of graph G =

Original: ( V , E ) is defined as follows:
Revised: ( V , E ) is defined as follows:

Original: BCVTree( G ) :
Revised: BCVTree( G ) :

Original: = (BCC V ( G ) ∪ V Cut , E V ) , where V Cut ⊂ V is the set containing all cut vertices of G and
Revised: = (BCC V ( G ) ∪ V Cut , E V ) , where V Cut ⊂ V is the set containing all cut vertices of G and

Original: E V :=
Revised: [Equation]

Original: (cid:8) {S , v } : S ∈ BCC V ( G ) , v ∈ V Cut , v ∈ S (cid:9) .

Original: The following theorem shows that all concepts related to biconnectivity can be efficiently computed.
Revised: The following theorem shows that all concepts related to biconnectivity can be efficiently computed.

Original: Theorem 2.5.
Revised: Theorem 2.5.

Original: (Tarjan, 1972)
Revised: (Tarjan, 1972)

Original: The problems related to biconnectivity, including identifying all cut vertices/edges, finding all biconnected components ( BCC V ( G ) and BCC E ( G ) ), and building block cut trees ( BCVTree( G ) and BCETree( G ) ), can all be solved using the Depth-First Search algorithm, within a computation complexity linear in the graph size, i.e. Θ( |V| + |E| ) .
Revised: The problems related to biconnectivity, including identifying all cut vertices/edges, finding all biconnected components ( BCC V ( G ) and BCC E ( G ) ), and building block cut trees ( BCVTree( G ) and BCETree( G ) ), can all be solved using the Depth-First Search algorithm, within a computation complexity linear in the graph size, i.e. Θ( |V| + |E| ) .

Original: Isomorphism and color refinement algorithms .
Revised: Isomorphism and color refinement algorithms .

Original: Two graphs G =
Revised: Two graphs G =

Original: ( V G , E G ) and H =
Revised: ( V G , E G ) and H =

Original: ( V H , E H ) are isomorphic (denoted as G ≃ H ) if there is an isomorphism (bijective mapping)
Revised: ( V H , E H ) are isomorphic (denoted as G ≃ H ) if there is an isomorphism (bijective mapping)

Original: f : V G → V H such that for any nodes u, v ∈ V G , { u, v } ∈ E G iff { f ( u ) , f ( v ) } ∈ E H .
Revised: f : V G → V H such that for any nodes u, v ∈ V G , { u, v } ∈ E G iff { f ( u ) , f ( v ) } ∈ E H .

Original: A color refinement algorithm is an algorithm that outputs a color mapping χ G : V G → C when taking graph G as input, where C is called the color set .
Revised: A color refinement algorithm is an algorithm that outputs a color mapping χ G : V G → C when taking graph G as input, where C is called the color set .

Original: A valid color refinement algorithm must preserve invariance under isomorphism, i.e., χ G ( u ) =
Revised: A valid color refinement algorithm must preserve invariance under isomorphism, i.e., χ G ( u ) =

Original: χ H ( f ( u )) for isomorphism f and node u ∈ V G .
Revised: χ H ( f ( u )) for isomorphism f and node u ∈ V G .

Original: As a result, it can be used as a necessary test for graph isomorphism by comparing the multisets {{ χ G ( u ) : u ∈ V G }} and {{ χ H ( u ) : u ∈ V H }} , which we call the graph representations .
Revised: As a result, it can be used as a necessary test for graph isomorphism by comparing the multisets {{ χ G ( u ) : u ∈ V G }} and {{ χ H ( u ) : u ∈ V H }} , which we call the graph representations .

Original: Similarly, χ G ( u ) can be seen as the node feature of u ∈ V G , and {{ χ G ( u ) , χ G ( v ) }} corresponds to the edge feature of { u, v } ∈ E G .
Revised: Similarly, χ G ( u ) can be seen as the node feature of u ∈ V G , and {{ χ G ( u ) , χ G ( v ) }} corresponds to the edge feature of { u, v } ∈ E G .

Original: All algorithms studied in this paper fit the color refinement framework, and please refer to Appendix B for a precise description of several representatives (e.g., the classic 1-WL and k -FWL algorithms).
Revised: All algorithms studied in this paper fit the color refinement framework, and please refer to Appendix B for a precise description of several representatives (e.g., the classic 1-WL and k -FWL algorithms).

Original: Problem setup .
Revised: Problem setup .

Original: This paper focuses on the following three types of problems with increasing difficulties.
Revised: This paper focuses on the following three types of problems with increasing difficulties.

Original: Firstly , we say a color refinement algorithm can distinguish whether a graph is vertex/edgebiconnected, if for any graphs G, H where G is vertex/edge-biconnected but H is not, their graph representations are different, i.e. {{ χ G ( u ) : u ∈ V G }} ̸
Revised: Firstly , we say a color refinement algorithm can distinguish whether a graph is vertex/edgebiconnected, if for any graphs G, H where G is vertex/edge-biconnected but H is not, their graph representations are different, i.e. {{ χ G ( u ) : u ∈ V G }} ̸

Original: = {{ χ H ( u ) : u ∈ V H }} .
Revised: = {{ χ H ( u ) : u ∈ V H }} .

Original: Secondly , we say a color refinement algorithm can identify cut vertices if for any graphs G, H and nodes u ∈ V G , v ∈
Revised: Secondly , we say a color refinement algorithm can identify cut vertices if for any graphs G, H and nodes u ∈ V G , v ∈

Original: V H where u is a cut vertex but v is not, their node features are different, i.e. χ G ( u ) ̸
Revised: V H where u is a cut vertex but v is not, their node features are different, i.e. χ G ( u ) ̸

Original: = χ H ( v ) .
Revised: = χ H ( v ) .

Original: Similarly, it can identify cut edges if for any { u, v } ∈ E G and { w, x } ∈ E H where { u, v } is a cut edge but { w, x } is not, their edge features are different, i.e. {{ χ G ( u ) , χ G ( v ) }} ̸ = {{ χ H ( w ) , χ H ( x ) }} .
Revised: Similarly, it can identify cut edges if for any { u, v } ∈ E G and { w, x } ∈ E H where { u, v } is a cut edge but { w, x } is not, their edge features are different, i.e. {{ χ G ( u ) , χ G ( v ) }} ̸ = {{ χ H ( w ) , χ H ( x ) }} .

Original: Finally , we say a color refinement algorithm can distinguish block cut-vertex/edge trees, if for any graphs G, H satisfying BCVTree( G ) ̸≃ BCVTree( H ) (or BCETree( G )
Revised: Finally , we say a color refinement algorithm can distinguish block cut-vertex/edge trees, if for any graphs G, H satisfying BCVTree( G ) ̸≃ BCVTree( H ) (or BCETree( G )

Original: ̸≃ BCETree( H ) ), their graph representations are different, i.e. {{ χ G ( u ) : u ∈ V G }} ̸ = {{ χ H ( u ) : u ∈ V H }} .
Revised: ̸≃ BCETree( H ) ), their graph representations are different, i.e. {{ χ G ( u ) : u ∈ V G }} ̸ = {{ χ H ( u ) : u ∈ V H }} .

Original:  I NVESTIGATING K NOWN GNN A RCHITECTURES VIA B ICONNECTIVITY
Revised:  I NVESTIGATING K NOWN GNN A RCHITECTURES VIA B ICONNECTIVITY

Original: In this section, we provide a comprehensive investigation of popular GNN variants in literature, including the classic MPNNs, Graph Substructure Networks (GSN) (Bouritsas et al., 2022) and its variant (Barcel ´ o et al., 2021), GNN with lifting transformations (MPSN and CWN) (Bodnar et al., 2021b;a), GraphSNN (Wijesinghe & Wang, 2022), and Subgraph GNNs (e.g., Bevilacqua et al.
Revised: In this section, we provide a comprehensive investigation of popular GNN variants in literature, including the classic MPNNs, Graph Substructure Networks (GSN) (Bouritsas et al., 2022) and its variant (Barcel´o et al., 2021), GNN with lifting transformations (MPSN and CWN) (Bodnar et al., 2021b;a), GraphSNN (Wijesinghe & Wang, 2022), and Subgraph GNNs (e.g., Bevilacqua et al.

Original: Surprisingly, we find most of these works are not expressive for any biconnectivity problems listed above.
Revised: Surprisingly, we find most of these works are not expressive for any biconnectivity problems listed above.

Original: The only exceptions are the ESAN (Bevilacqua et al., 2022) and several variants, where we give a rigorous justification of their expressive power for both vertex/edge-biconnectivity.
Revised: The only exceptions are the ESAN (Bevilacqua et al., 2022) and several variants, where we give a rigorous justification of their expressive power for both vertex/edge-biconnectivity.

Original: 3. C OUNTEREXAMPLES
Revised: 3. C OUNTEREXAMPLES

Original: 1-WL/MPNNs .
Revised: 1-WL/MPNNs .

Original: We first consider the classic 1-WL.
Revised: We first consider the classic 1-WL.

Original: We provide two principled class of counterexamples which are formally defined in Examples C.9 and C.10, with a few special cases illustrated in
Revised: We provide two principled class of counterexamples which are formally defined in Examples C.9 and C.10, with a few special cases illustrated in

Original: Figure 2.
Revised: Figure 2.

Original: For each pair of graphs in Figure 2, the color of each node is drawn according to the 1-WL color mapping.
Revised: For each pair of graphs in Figure 2, the color of each node is drawn according to the 1-WL color mapping.

Original: It can be seen that the two graph representations are the same.
Revised: It can be seen that the two graph representations are the same.

Original: Therefore, 1-WL cannot distinguish any biconnectivity problem listed in Section 2. 
Revised: Therefore, 1-WL cannot distinguish any biconnectivity problem listed in Section 2. [Figure]

Original: Substructure Counting WL/GSN .
Revised: Substructure Counting WL/GSN .

Original: Bouritsas et al.
Revised: Bouritsas et al.

Original: (2022) developed a principled approach to boost the expressiveness of MPNNs by incorporating substructure counts into node features or the 1WL aggregation procedure.
Revised: (2022) developed a principled approach to boost the expressiveness of MPNNs by incorporating substructure counts into node features or the 1WL aggregation procedure.

Original: The resulting algorithm, which we call the SC-WL, is detailed in Appendix B.3.
Revised: The resulting algorithm, which we call the SC-WL, is detailed in Appendix B.3.

Original: However, we show no matter what sub-structures are used, the corresponding GSN still cannot solve any biconnectivity problem listed in Section 2.
Revised: However, we show no matter what sub-structures are used, the corresponding GSN still cannot solve any biconnectivity problem listed in Section 2.

Original: We give a proof in Appendix C.2 for the general case that allows arbitrary substructures, based on Examples C.9 and C.10.
Revised: We give a proof in Appendix C.2 for the general case that allows arbitrary substructures, based on Examples C.9 and C.10.

Original: We also point out that our negative result applies to the similar GNN variant in Barcel´o et al.[Figure]
Revised: We also point out that our negative result applies to the similar GNN variant in Barcel ´ o et al.

Original: Theorem 3.1.
Revised: Theorem 3.1.

Original: Let H =
Revised: Let H =

Original: { H 1 , · · · , H k } , H i =
Revised: { H 1 , · · · , H k } , H i =

Original: ( V i , E i ) be any set of connected graphs and denote n = max i ∈ [ k ] |V i | .
Revised: ( V i , E i ) be any set of connected graphs and denote n = max i ∈ [ k ] |V i | .

Original: Then SC-WL (Appendix B.3) using the substructure set H cannot solve any vertex/edge-biconnectivity problem listed in Section 2.
Revised: Then SC-WL (Appendix B.3) using the substructure set H cannot solve any vertex/edge-biconnectivity problem listed in Section 2.

Original: Moreover, there exist counterexample graphs whose sizes (both in terms of vertices and edges) are O ( n ) .
Revised: Moreover, there exist counterexample graphs whose sizes (both in terms of vertices and edges) are O ( n ) .

Original: GNNs with lifting transformations (MPSN/CWN) .
Revised: GNNs with lifting transformations (MPSN/CWN) .

Original: Bodnar et al.
Revised: Bodnar et al.

Original: (2021b;a) considered another approach to design powerful GNNs by using graph lifting transformations.
Revised: (2021b;a) considered another approach to design powerful GNNs by using graph lifting transformations.

Original: In a nutshell, these approaches exploit higher-order graph structures such as cliques and cycles to design new WL aggregation procedures.
Revised: In a nutshell, these approaches exploit higher-order graph structures such as cliques and cycles to design new WL aggregation procedures.

Original: Unfortunately, we show the resulting algorithms, called the SWL and CWL, still cannot solve any biconnectivity problem.
Revised: Unfortunately, we show the resulting algorithms, called the SWL and CWL, still cannot solve any biconnectivity problem.

Original: Please see Appendix C.2 (Proposition C.12) for details.
Revised: Please see Appendix C.2 (Proposition C.12) for details.

Original: Other GNN variants .
Revised: Other GNN variants .

Original: In Appendix C.2, wefurther discuss other recently proposed GNN variants, such as GraphSNN (Wijesinghe & Wang, 2022) and GNN-AK
Revised: In Appendix C.2, we discuss other recently proposed GNNs, such as GraphSNN (Wijesinghe & Wang, 2022), GNN-AK

Original: (Zhao et al., 2022).
Revised: (Zhao et al., 2022), and NGNN (Zhang & Li, 2021).

Original: Due to space limit, we defer the corresponding negative results into Propositions C.13 and C.15, respectively.
Revised: Due to space limit, we defer the corresponding negative results in Propositions C.13, C.15 and C.16.

Original: 3. P ROVABLE EXPRESSIVENESS OF ESAN AND DSS-WL
Revised: 3. P ROVABLE EXPRESSIVENESS OF ESAN AND DSS-WL

Original: We next switch our attention to a new type of GNN framework proposed in Bevilacqua et al.
Revised: We next switch our attention to a new type of GNN framework proposed in Bevilacqua et al.

Original: , called the Equivariant Subgraph Aggregation Networks (ESAN).
Revised: , called the Equivariant Subgraph Aggregation Networks (ESAN).

Original: The central algorithm in EASN is called the DSS-WL.
Revised: The central algorithm in EASN is called the DSS-WL.

Original: Given a graph G , DSS-WL first generates a bag of vertex-shared (sub)graphs
Revised: Given a graph G , DSS-WL first generates a bag of vertex-shared (sub)graphs

Original: B πG = {{ G 1 , · · · , G m }} according to a graph generation policy π .
Revised: B πG = {{ G 1 , · · · , G m }} according to a graph generation policy π .

Original: Then in each iteration t , the algorithm refines the color of each node v in each subgraph G i by jointly aggregating its neighboring colors in the own subgraph and across all subgraphs.
Revised: Then in each iteration t , the algorithm refines the color of each node v in each subgraph G i by jointly aggregating its neighboring colors in the own subgraph and across all subgraphs.

Original: The aggregation formula can be written as:
Revised: The aggregation formula can be written as:

Original: [Equation]
Revised: [Equation]

Original:  where hash is a perfect hash function.
Revised: 2) where hash is a perfect hash function.

Original: DSS-WL terminates when χ tG induces a stable vertex partition.
Revised: DSS-WL terminates when χ tG induces a stable vertex partition.

Original: In this paper, we consider node-based graph generation policies, for which each subgraph is associated to a specific node, i.e. B πG = {{ G v : v ∈ V}} .
Revised: In this paper, we consider node-based graph generation policies, for which each subgraph is associated to a specific node, i.e. B πG = {{ G v : v ∈ V}} .

Original: Some popular choices are node deletion π ND , node marking π NM , k -ego-network π EGO( k ) , and its node marking version π EGOM( k ) .
Revised: Some popular choices are node deletion π ND , node marking π NM , k -ego-network π EGO( k ) , and its node marking version π EGOM( k ) .

Original: A full description of DSS-WL as well as different policies can be found in Appendix B.4 (Algorithm 3).
Revised: A full description of DSS-WL as well as different policies can be found in Appendix B.4 (Algorithm 3).

Original: A fundamental question regarding DSS-WL is how expressive it is.
Revised: A fundamental question regarding DSS-WL is how expressive it is.

Original: While a straightforward analysis shows that DSS-WL is strictly more powerful than 1-WL, an in-depth understanding on what additional power DSS-WL gains over 1-WL is still limited.
Revised: While a straightforward analysis shows that DSS-WL is strictly more powerful than 1-WL, an in-depth understanding on what additional power DSS-WL gains over 1-WL is still limited.

Original: The only new result is the very recent work of Frasca et al.
Revised: The only new result is the very recent work of Frasca et al.

Original: (2022), who showed a 3-WL upper bound for the expressivity of DSS-WL.
Revised: (2022), who showed a 3-WL upper bound for the expressivity of DSS-WL.

Original: Yet, such a result actually gives a limitation of DSS-WL rather than showing its power.
Revised: Yet, such a result actually gives a limitation of DSS-WL rather than showing its power.

Original: Moreover, there is a large gap between the highly strong 3-WL and the weak 1-WL.
Revised: Moreover, there is a large gap between the highly strong 3-WL and the weak 1-WL.

Original: In the following, we take a different perspective and prove that DSS-WL is expressive for both types of biconnectivity problems.
Revised: In the following, we take a different perspective and prove that DSS-WL is expressive for both types of biconnectivity problems.

Original: Theorem 3.2.
Revised: Theorem 3.2.

Original: Let G =
Revised: Let G =

Original: ( V G , E G ) and H =
Revised: ( V G , E G ) and H =

Original: ( V H , E H ) be two graphs, and let χ G and χ H be the corresponding DSS-WL color mapping with node marking policy.
Revised: ( V H , E H ) be two graphs, and let χ G and χ H be the corresponding DSS-WL color mapping with node marking policy.

Original: Then the following holds
Revised: Then the following holds:

Original: : • For any two nodes w ∈ V G and x ∈ V H , if χ G ( w ) =
Revised: • For any two nodes w ∈ V G and x ∈ V H , if χ G ( w ) =

Original: χ H ( x ) , then w is a cut vertex if and only if x is a cut vertex.
Revised: χ H ( x ) , then w is a cut vertex if and only if x is a cut vertex.

Original: • For any two edges { w 1 , w 2 } ∈ E G and { x 1 , x 2 } ∈ E H , if {{ χ G ( w 1 ) , χ G ( w 2 ) }} = {{ χ H ( x 1 ) , χ H ( x 2 ) }} , then { w 1 , w 2 } is a cut edge if and only if { x 1 , x 2 } is a cut edge.
Revised: • For any two edges { w 1 , w 2 } ∈ E G and { x 1 , x 2 } ∈ E H , if {{ χ G ( w 1 ) , χ G ( w 2 ) }} = {{ χ H ( x 1 ) , χ H ( x 2 ) }} , then { w 1 , w 2 } is a cut edge if and only if { x 1 , x 2 } is a cut edge.

Original: The proof of Theorem 3.2 is highly technical and is deferred to Appendix C.3.
Revised: The proof of Theorem 3.2 is highly technical and is deferred to Appendix C.3.

Original: By using the basic results derived in Appendix C.1, we conduct a careful analysis of the DSS-WL color mapping and discover several important properties.
Revised: By using the basic results derived in Appendix C.1, we conduct a careful analysis of the DSS-WL color mapping and discover several important properties.

Original: They give insights on why DSS-WL can succeed in distinguishing biconnectivity, as we will discuss below.
Revised: They give insights on why DSS-WL can succeed in distinguishing biconnectivity, as we will discuss below.

Original: How can DSS-WL distinguish biconnectivity?
Revised: How can DSS-WL distinguish biconnectivity?

Original: We find that a crucial advantage of DSS-WL over the classic 1-WL is that DSS-WL color mapping implicitly encodes distance information (see
Revised: We find that a crucial advantage of DSS-WL over the classic 1-WL is that DSS-WL color mapping implicitly encodes distance information (see

Original: Lemma C.19(e) and Corollary C.24).
Revised: Lemma C.19(e) and Corollary C.24).

Original: For example, two nodes u ∈ V G , v ∈ V H will have different DSS-WL colors if the distance set {{ dis G ( u, w ) : w ∈ V G }} differs from {{ dis G ( v, w ) : w ∈ V H }} .
Revised: For example, two nodes u ∈ V G , v ∈ V H will have different DSS-WL colors if the distance set {{ dis G ( u, w ) : w ∈ V G }} differs from {{ dis H ( v, w ) : w ∈ V H }} .

Original: Our proof highlights that distance information plays a vital role in distinguishing edgebiconnectivity when combining with color refinement algorithms (detailed in Section 4), and it also helps distinguish vertex-biconnectivity (see the proof of Lemma C.22).
Revised: Our proof highlights that distance information plays a vital role in distinguishing edgebiconnectivity when combining with color refinement algorithms (detailed in Section 4), and it also helps distinguish vertex-biconnectivity (see the proof of Lemma C.22).

Original: Consequently, our analysis provides a novel understanding and a strong justification for the success of DSS-WL in two aspects: the graph representation computed by DSS-WL intrinsically encodes distance and biconnectivity information, both of which are fundamental structural properties of graphs but are lacking in 1-WL.
Revised: Consequently, our analysis provides a novel understanding and a strong justification for the success of DSS-WL in two aspects: the graph representation computed by DSS-WL intrinsically encodes distance and biconnectivity information, both of which are fundamental structural properties of graphs but are lacking in 1-WL.

Original: Discussions on graph generation policies .
Revised: Discussions on graph generation policies .

Original: Note that Theorem 3.2 holds for node marking policy.
Revised: Note that Theorem 3.2 holds for node marking policy.

Original: In fact, the ability of DSS-WL to encode distance information heavily relies on node marking as shown in the proof of Lemma C.19.
Revised: In fact, the ability of DSS-WL to encode distance information heavily relies on node marking as shown in the proof of Lemma C.19.

Original: In contrast, we prove that the ego-network policy π EGO( k ) cannot distinguish cut vertices (Proposition C.14), using the counterexample given in Figure 2(c).
Revised: In contrast, we prove that the ego-network policy π EGO( k ) cannot distinguish cut vertices (Proposition C.14), using the counterexample given in Figure 2(c).

Original: Therefore, our result shows an inherent advantage of node marking than the ego-network policy in distinguishing a class of non-isomorphic graphs, which is raised as an open question in Bevilacqua et al.
Revised: Therefore, our result shows an inherent advantage of node marking than the ego-network policy in distinguishing a class of non-isomorphic graphs, which is raised as an open question in Bevilacqua et al.

Original: (2022, Section 5).
Revised: (2022, Section 5).

Original: It also highlights a theoretical limitation of π EGO( k ) compared with its node marking version π EGOM( k ) , a subtle difference that may not have received sufficient attention yet.
Revised: It also highlights a theoretical limitation of π EGO( k ) compared with its node marking version π EGOM( k ) , a subtle difference that may not have received sufficient attention yet.

Original: For example,  the GNN-AK  architecture (Zhao et al., 2022) cannot solve vertex-biconnectivity problems since it is similar to π EGO( k ) (see Proposition C.15).
Revised: For example, both the GNN-AK and GNN-AK-ctx architecture (Zhao et al., 2022) cannot solve vertex-biconnectivity problems since it is similar to π EGO( k ) (see Proposition C.15).

Original: On the other hand, the NGNN architecture (Zhang & Li, 2021) does not suffer from such a drawback although it also uses π EGO( k ) , because it further adds distance encoding in each subgraph (which is more expressive than node marking).
Revised: On the other hand, the GNN-AK+ does not suffer from such a drawback although it also uses π EGO( k ) , because it further adds distance encoding in each subgraph (which is more expressive than node marking).

Original: Discussions on DS-WL .
Revised: Discussions on DS-WL .

Original: Bevilacqua et al.
Revised: Bevilacqua et al.

Original: ; Cotta et al.
Revised: ; Cotta et al.

Original: (2021) also considered a weaker version of DSS-WL, called the DS-WL, which aggregates the node color in each subgraph without interaction across different subgraphs (see formula (10)).
Revised: (2021) also considered a weaker version of DSS-WL, called the DS-WL, which aggregates the node color in each subgraph without interaction across different subgraphs (see formula (10)).

Original: We show in Proposition C.16 that unfortunately, DS-WL with common node-based policies cannot identify cut vertices when the color of each node v is defined as its associated subgraph representation G v .
Revised: We show in Proposition C.16 that unfortunately, DS-WL with common node-based policies cannot identify cut vertices when the color of each node v is defined as its associated subgraph representation G v .

Original: This theoretically reveals the importance of cross-graph aggregation and justifies the design of DSS-WL.
Revised: This theoretically reveals the importance of cross-graph aggregation and justifies the design of DSS-WL.

Original: Finally, we point out that Qian et al.
Revised: Finally, we point out that Qian et al.

Original: (2022) very recently proposed an extension of DS-WL that adds a final cross-graph aggregation procedure, for which our negative result may not hold.
Revised: (2022) very recently proposed an extension of DS-WL that adds a final cross-graph aggregation procedure, for which our negative result may not hold.

Original: It may be an interesting direction to theoretically analyze the expressiveness of this type of DS-WL in future work.
Revised: It may be an interesting direction to theoretically analyze the expressiveness of this type of DS-WL in future work.

Original:  G ENERALIZED D ISTANCE W EISFEILER -L EHMAN T EST
Revised:  G ENERALIZED D ISTANCE W EISFEILER -L EHMAN T EST

Original: After an extensive review of prior GNN architectures, in this section we would like to formally study the following problem: can we design a principled and efficient GNN framework with provable expressiveness for biconnectivity?
Revised: After an extensive review of prior GNN architectures, in this section we would like to formally study the following problem: can we design a principled and efficient GNN framework with provable expressiveness for biconnectivity?

Original: In fact, while in Section 3.2 we have proved that DSS-WL can solve biconnectivity problems, it is still far from enough.
Revised: In fact, while in Section 3.2 we have proved that DSS-WL can solve biconnectivity problems, it is still far from enough.

Original: Firstly, the corresponding GNNs based on
Revised: Firstly, the corresponding GNNs based on

Original: DSS-WL is usually sophisticated due to the complex aggregation formula (1), which inspires us to study whether simpler architectures exist.
Revised: DSS-WL is usually sophisticated due to the complex aggregation formula (1), which inspires us to study whether simpler architectures exist.

Original: More importantly, DSS-WL suffers from high computational costs in both time and memory.
Revised: More importantly, DSS-WL suffers from high computational costs in both time and memory.

Original: Indeed, it requires Θ( n 2 ) space and Θ( nm ) time per iteration (using policy π NM ) to compute node colors for a graph with n nodes and m edges, which is n times costly than 1-WL.
Revised: Indeed, it requires Θ( n 2 ) space and Θ( nm ) time per iteration (using policy π NM ) to compute node colors for a graph with n nodes and m edges, which is n times costly than 1-WL.

Original: Given the theoretical linear lower bound in Theorem 2.5, one may naturally raise the question of how to close the gap by developing more efficient color refinement algorithms.
Revised: Given the theoretical linear lower bound in Theorem 2.5, one may naturally raise the question of how to close the gap by developing more efficient color refinement algorithms.

Original: We approach the problem by rethinking the classic 1-WL test.
Revised: We approach the problem by rethinking the classic 1-WL test.

Original: We argue that a major weakness of 1-WL is that it is agnostic to distance information between nodes, partly because each node can only “see” its neighbors in aggregation.
Revised: We argue that a major weakness of 1-WL is that it is agnostic to distance information between nodes, partly because each node can only “see” its neighbors in aggregation.

Original: On the other hand, the DSS-WL color mapping implicitly encodes distance information as shown in Section 3.2, which inspires us to formally study whether incorporating distance in the aggregation procedure is crucial for solving biconnectivity problems.
Revised: On the other hand, the DSS-WL color mapping implicitly encodes distance information as shown in Section 3.2, which inspires us to formally study whether incorporating distance in the aggregation procedure is crucial for solving biconnectivity problems.

Original: To this end, we introduce a novel color refinement framework which we call Generalized Distance
Revised: To this end, we introduce a novel color refinement framework which we call Generalized Distance

Original: Weisfeiler-Lehman (GD-WL).
Revised: Weisfeiler-Lehman (GD-WL).

Original: The update rule of GD-WL is very simple and can be written as:
Revised: The update rule of GD-WL is very simple and can be written as:

Original: [Equation]
Revised: [Equation]

Original: [Equation]

Original: ) where d G can be an arbitrary distance metric.
Revised: where d G can be an arbitrary distance metric.

Original: The full algorithm is described in Algorithm 4.
Revised: The full algorithm is described in Algorithm 4.

Original: SPD-WL for edge-biconnectivity .
Revised: SPD-WL for edge-biconnectivity .

Original: As a special case, when choosing the shortest path distance d G = dis G , we obtain an algorithm which we call SPD-WL.
Revised: As a special case, when choosing the shortest path distance d G = dis G , we obtain an algorithm which we call SPD-WL.

Original: It can be equivalently written as
Revised: It can be equivalently written as

Original: [Equation]
Revised: [Equation]

Original: From (4) it is clear that SPD-WL is strictly more powerful than 1-WL since it additionally aggregates the k -hop neighbors for all k > 1 .
Revised: From (4) it is clear that SPD-WL is strictly more powerful than 1-WL since it additionally aggregates the k -hop neighbors for all k > 1 .

Original: There have been several prior works related to SPD-WL, including using distance encoding as node features (Li et al., 2020) or performing k -hop aggregation for some small k (see Appendix D.2 for more related works and discussions).
Revised: There have been several prior works related to SPD-WL, including using distance encoding as node features (Li et al., 2020) or performing k -hop aggregation for some small k (see Appendix D.2 for more related works and discussions).

Original: Yet, these works are either purely empirical or provide limited theoretical analysis (e.g., by focusing only on regular graphs).
Revised: Yet, these works are either purely empirical or provide limited theoretical analysis (e.g., by focusing only on regular graphs).

Original: Instead, we introduce the general and more expressive SPD-WL framework with a rather different motivation and perform a systematic study on its expressive power.
Revised: Instead, we introduce the general and more expressive SPD-WL framework with a rather different motivation and perform a systematic study on its expressive power.

Original: Our key result confirms that SPD-WL is fully expressive for all edge-biconnectivity problems listed in Section 2.
Revised: Our key result confirms that SPD-WL is fully expressive for all edge-biconnectivity problems listed in Section 2.

Original: Theorem 4.1.
Revised: Theorem 4.1.

Original: Let G =
Revised: Let G =

Original: ( V G , E G ) and H =
Revised: ( V G , E G ) and H =

Original: ( V H , E H ) be two graphs, and let χ G and χ H be the corresponding SPD-WL color mapping.
Revised: ( V H , E H ) be two graphs, and let χ G and χ H be the corresponding SPD-WL color mapping.

Original: Then the following holds:
Revised: Then the following holds:

Original: • For any two edges { w 1 , w 2 } ∈ E G and { x 1 , x 2 } ∈ E H , if {{ χ G ( w 1 ) , χ G ( w 2 ) }} = {{ χ H ( x 1 ) , χ H ( x 2 ) }} , then { w 1 , w 2 } is a cut edge if and only if { x 1 , x 2 } is a cut edge.
Revised: • For any two edges { w 1 , w 2 } ∈ E G and { x 1 , x 2 } ∈ E H , if {{ χ G ( w 1 ) , χ G ( w 2 ) }} = {{ χ H ( x 1 ) , χ H ( x 2 ) }} , then { w 1 , w 2 } is a cut edge if and only if { x 1 , x 2 } is a cut edge.

Original: • If {{ χ G ( w ) : w ∈ V G }} = {{ χ H ( w ) : w ∈ V H }} , then BCETree( G ) ≃
Revised: • If {{ χ G ( w ) : w ∈ V G }} = {{ χ H ( w ) : w ∈ V H }} , then BCETree( G ) ≃

Original: BCETree
Revised: BCETree

Original: ( H ) .
Revised: ( H ) .

Original: Theorem 4.1 is highly non-trivial and perhaps surprising at first sight, as it combines three seemingly unrelated concepts (i.e., SPD, biconnectivity, and the WL test) into a unified conclusion.
Revised: Theorem 4.1 is highly non-trivial and perhaps surprising at first sight, as it combines three seemingly unrelated concepts (i.e., SPD, biconnectivity, and the WL test) into a unified conclusion.

Original: We give a proof in Appendix C.4, which separately considers two cases: χ G ( w 1 ) ̸
Revised: We give a proof in Appendix C.4, which separately considers two cases: χ G ( w 1 ) ̸

Original: = χ G ( w 2 ) and χ G ( w 1 ) =
Revised: = χ G ( w 2 ) and χ G ( w 1 ) =

Original: χ G ( w 2 ) (see Figure 2(b,d) for examples).
Revised: χ G ( w 2 ) (see Figure 2(b,d) for examples).

Original: For each case, the key technique in the proof is to construct an auxiliary graph (Definitions C.26 and C.34) that precisely characterizes the structural relationship between nodes that have specific colors (see Corollaries C.31 and C.40).
Revised: For each case, the key technique in the proof is to construct an auxiliary graph (Definitions C.26 and C.34) that precisely characterizes the structural relationship between nodes that have specific colors (see Corollaries C.31 and C.40).

Original: Finally, we highlight that the second item of Theorem 4.1 may be particularly interesting: while distinguishing general nonisomorphic graphs are known to be hard (Cai et al., 1992; Babai, 2016), we show distinguishing non-isomorphic graphs with different block cut-edge trees can be much easily solved by SPD-WL.
Revised: Finally, we highlight that the second item of Theorem 4.1 may be particularly interesting: while distinguishing general nonisomorphic graphs are known to be hard (Cai et al., 1992; Babai, 2016), we show distinguishing non-isomorphic graphs with different block cut-edge trees can be much easily solved by SPD-WL.

Original: RD-WL for vertex-biconnectivity .
Revised: RD-WL for vertex-biconnectivity .

Original: Unfortunately, while SPD-WL is fully expressive for edgebiconnectivity, it is not expressive for vertex-biconnectivity.
Revised: Unfortunately, while SPD-WL is fully expressive for edgebiconnectivity, it is not expressive for vertex-biconnectivity.

Original: We give a simple counterexample in
Revised: We give a simple counterexample in

Original: Figure 2(c), where SPD-WL cannot distinguish the two graphs.
Revised: Figure 2(c), where SPD-WL cannot distinguish the two graphs.

Original: Nevertheless, we find that by using a different distance metric, problems related to vertex-biconnectivity can also be fully solved.
Revised: Nevertheless, we find that by using a different distance metric, problems related to vertex-biconnectivity can also be fully solved.

Original: We propose such a choice called the Resistance Distance (RD) (denoted as dis R G ).
Revised: We propose such a choice called the Resistance Distance (RD) (denoted as dis R G ).

Original: Like SPD, RD is also a basic metric in graph theory (Doyle & Snell, 1984; Klein & Randi ´ c, 1993) and has been widely used to characterize the relationship between nodes (Sanmartın et al., 2022; Velingker et al., 2022).
Revised: Like SPD, RD is also a basic metric in graph theory (Doyle & Snell, 1984; Klein & Randi´c, 1993) and has been widely used to characterize the relationship between nodes (Sanmartın et al., 2022; Velingker et al., 2022).

Original: Formally, the value of dis R G ( u, v ) is defined to be the effective resistance between nodes u and v when treating G as an electrical network where each edge corresponds to a resistance of one ohm.
Revised: Formally, the value of dis R G ( u, v ) is defined to be the effective resistance between nodes u and v when treating G as an electrical network where each edge corresponds to a resistance of one ohm.

Original: RD has many elegant properties.
Revised: RD has many elegant properties.

Original: First, it is a valid metric : indeed, RD is non-negative, semidefinite, symmetric, and satisfies the triangular inequality (see Appendix E.2).
Revised: First, it is a valid metric : indeed, RD is non-negative, semidefinite, symmetric, and satisfies the triangular inequality (see Appendix E.2).

Original: Moreover, similar to SPD, we also have 0 ≤ dis R G ( u, v ) ≤ n − 1 , and dis R G ( u, v ) =
Revised: Moreover, similar to SPD, we also have 0 ≤ dis R G ( u, v ) ≤ n − 1 , and dis R G ( u, v ) =

Original: dis G ( u, v ) if G is a tree.
Revised: dis G ( u, v ) if G is a tree.

Original: In Appendix E.2, we further show that RD is highly related to the graph Laplacian and can be efficiently calculated.
Revised: In Appendix E.2, we further show that RD is highly related to the graph Laplacian and can be efficiently calculated.

Original: Theorem 4.2.
Revised: Theorem 4.2.

Original: Let G =
Revised: Let G =

Original: ( V G , E G ) and H =
Revised: ( V G , E G ) and H =

Original: ( V H , E H ) be two graphs, and let χ G and χ H be the corresponding RD-WL color mapping.
Revised: ( V H , E H ) be two graphs, and let χ G and χ H be the corresponding RD-WL color mapping.

Original: Then the following holds:
Revised: Then the following holds:

Original: • For any two nodes w ∈ V G and x ∈ V H , if χ G ( w ) =
Revised: • For any two nodes w ∈ V G and x ∈ V H , if χ G ( w ) =

Original: χ H ( x ) , then w is a cut vertex if and only if x is a cut vertex.
Revised: χ H ( x ) , then w is a cut vertex if and only if x is a cut vertex.

Original: • If {{ χ G ( w ) : w ∈ V G }} = {{ χ H ( w ) : w ∈ V H }} , then BCVTree( G ) ≃ BCVTree( H ) .
Revised: • If {{ χ G ( w ) : w ∈ V G }} = {{ χ H ( w ) : w ∈ V H }} , then BCVTree( G ) ≃ BCVTree( H ) .

Original: The form of Theorem 4.2 exactly parallels Theorem 4.1, which shows that RD-WL is fully expressive for vertex-biconnectivity.
Revised: The form of Theorem 4.2 exactly parallels Theorem 4.1, which shows that RD-WL is fully expressive for vertex-biconnectivity.

Original: We give a proof of Theorem 4.1 in Appendix C.5.
Revised: We give a proof of Theorem 4.1 in Appendix C.5.

Original: In particular, the proof of the second item is highly technical due to the challenges in analyzing the (complex) structure of the block cut-vertex tree.
Revised: In particular, the proof of the second item is highly technical due to the challenges in analyzing the (complex) structure of the block cut-vertex tree.

Original: It also highlights that distinguishing non-isomorphic graphs that have different BCVTrees is much easier than the general case.
Revised: It also highlights that distinguishing non-isomorphic graphs that have different BCVTrees is much easier than the general case.

Original: Combining Theorems 4.1 and 4.2 immediately yields the following corollary, showing that all biconnectivity problems can be solved within our proposed GD-WL framework.
Revised: Combining Theorems 4.1 and 4.2 immediately yields the following corollary, showing that all biconnectivity problems can be solved within our proposed GD-WL framework.

Original: Corollary 4.3.
Revised: Corollary 4.3.

Original: When using both SPD and RD (i.e., by setting d G ( u, v ) :
Revised: When using both SPD and RD (i.e., by setting d G ( u, v ) :

Original: = (dis G ( u, v ) , dis R G ( u, v )) ), the corresponding GD-WL is fully expressive for both vertex-biconnectivity and edge-biconnectivity.
Revised: = (dis G ( u, v ) , dis R G ( u, v )) ), the corresponding GD-WL is fully expressive for both vertex-biconnectivity and edge-biconnectivity.

Original: Computational cost .
Revised: Computational cost .

Original: The GD-WL framework only needs a complexity of Θ( n ) space and Θ( n 2 ) time per-iteration for a graph of n nodes and m edges, both of which are strictly less than DSS-WL.
Revised: The GD-WL framework only needs a complexity of Θ( n ) space and Θ( n 2 ) time per-iteration for a graph of n nodes and m edges, both of which are strictly less than DSS-WL.

Original: In particular, GD-WL has the same space complexity as 1-WL, which can be crucial for large-scale tasks.
Revised: In particular, GD-WL has the same space complexity as 1-WL, which can be crucial for large-scale tasks.

Original: On the other hand, one may ask how much computational overhead there is in preprocessing pairwise distances between nodes.
Revised: On the other hand, one may ask how much computational overhead there is in preprocessing pairwise distances between nodes.

Original: We show in Appendix E that the computational cost can be trivially upper bounded by O ( nm ) for SPD and O ( n 3 ) for RD.
Revised: We show in Appendix E that the computational cost can be trivially upper bounded by O ( nm ) for SPD and O ( n 3 ) for RD.

Original: Note that the preprocessing step only needs to be executed once, and we find that the cost is negligible compared to the GNN architecture.
Revised: Note that the preprocessing step only needs to be executed once, and we find that the cost is negligible compared to the GNN architecture.

Original: Practical Implementation .
Revised: Practical implementation .

Original: One of the main advantages of GD-WL is its high degree of parallelizability.
Revised: One of the main advantages of GD-WL is its high degree of parallelizability.

Original: In particular, we find GD-WL can be easily implemented using a Transformer-like architecture by injecting distance information into Multi-head Attention (Vaswani et al., 2017), similar to the structural encoding in Graphormer (Ying et al., 2021a).
Revised: In particular, we find GD-WL can be easily implemented using a Transformer-like architecture by injecting distance information into Multi-head Attention (Vaswani et al., 2017), similar to the structural encoding in Graphormer (Ying et al., 2021a).

Original: The attention layer can be written as:
Revised: The attention layer can be written as:

Original: [Equation]
Revised: [Equation]

Original: where X ∈ R n × d is the input node features of the previous layer, D ∈ R n × n is the distance matrix such that D uv = d G ( u, v ) , W hQ , W hK ,
Revised: where X ∈ R n × d is the input node features of the previous layer, D ∈ R n × n is the distance matrix such that D uv = d G ( u, v ) , W hQ , W hK ,

Original: W hV ∈ R
Revised: W hV ∈ R

Original: d × d H are learnable weight matrices of the h -th head, ϕ h 1 and ϕ h 2 are elementwise functions applied to D (possibly parameterized), and ⊙ denotes the elementwise multiplication.
Revised: d × d H are learnable weight matrices of the h -th head, ϕ h 1 and ϕ h 2 are elementwise functions applied to D (possibly parameterized), and ⊙ denotes the elementwise multiplication.

Original: The results Y h ∈ R n × d H across all heads h are then combined and projected to obtain the final output Y =
Revised: The results Y h ∈ R n × d H across all heads h are then combined and projected to obtain the final output Y =

Original: (cid:80) h
Revised: (cid:80) h

Original: Y h W h O where W hO ∈ R d H × d .
Revised: Y h W hO where W hO ∈ R d H × d .

Original: We call the resulting architecture Graphormer-GD, and the full structure of Graphormer-GD is provided in Appendix E.3.
Revised: We call the resulting architecture Graphormer-GD, and the full structure of Graphormer-GD is provided in Appendix E.3.

Original: It is easy to see that the mapping from X to Y in (5) is equivariant and simulates the GD-WL aggregation.
Revised: It is easy to see that the mapping from X to Y in (5) is equivariant and simulates the GD-WL aggregation.

Original: Importantly, we have the following expressivity result, which precisely characterizes the power and limits of Graphormer-GD.
Revised: Importantly, we have the following expressivity result, which precisely characterizes the power and limits of Graphormer-GD.

Original: We give a proof in Appendix E.3.
Revised: We give a proof in Appendix E.3.

Original: Theorem 4.4.
Revised: Theorem 4.4.

Original: Graphormer-GD is at most as powerful as GD-WL in distinguishing non-isomorphic graphs.
Revised: Graphormer-GD is at most as powerful as GD-WL in distinguishing non-isomorphic graphs.

Original: Moreover, when choosing proper functions ϕ h 1 and ϕ h 2 and using a sufficiently large number of heads and layers, Graphormer-GD is as powerful as GD-WL.
Revised: Moreover, when choosing proper functions ϕ h 1 and ϕ h 2 and using a sufficiently large number of heads and layers, Graphormer-GD is as powerful as GD-WL.

Original: A final remark on the expressivity upper bound of GD-WL .
Revised: On the expressivity upper bound of GD-WL .

Original: To complete the theoretical analysis, we finally provide an upper bound of the expressive power for our proposed SPD-WL and RD-WL, by studying the relationship with the standard 2-FWL (3-WL) algorithm.
Revised: To complete the theoretical analysis, we finally provide an upper bound of the expressive power for our proposed SPD-WL and RD-WL, by studying the relationship with the standard 2-FWL (3-WL) algorithm.

Original: Theorem 4.5.
Revised: Theorem 4.5.

Original: The 2-FWL algorithm is more powerful than both SPD-WL and RD-WL.
Revised: The 2-FWL algorithm is more powerful than both SPD-WL and RD-WL.

Original: Formally, the 2-FWL color mapping induces a finer vertex partition than that of both SPD-WL and RD-WL.
Revised: Formally, the 2-FWL color mapping induces a finer vertex partition than that of both SPD-WL and RD-WL.

Original: We give a proof in Appendix C.6.
Revised: We give a proof in Appendix C.6.

Original: Using Theorem 4.5, we arrive at the concluding corollary:
Revised: Using Theorem 4.5, we arrive at the concluding corollary:

Original: Corollary 4.6.
Revised: Corollary 4.6.

Original: The 2-FWL is fully expressive for both vertex-biconnectivity and edge-biconnectivity.
Revised: The 2-FWL is fully expressive for both vertex-biconnectivity and edge-biconnectivity.

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: [Table]

Original: In this section, we perform empirical evaluations of our proposed Graphormer-GD.
Revised: In this section, we perform empirical evaluations of our proposed Graphormer-GD.

Original: We mainly consider the following two sets of experiments.
Revised: We mainly consider the following two sets of experiments.

Original: Firstly , we would like to verify whether Graphormer-GD can indeed learn biconnectivity-related metrics easily as our theory predicts.
Revised: Firstly , we would like to verify whether GraphormerGD can indeed learn biconnectivity-related metrics easily as our theory predicts.

Original: Secondly , we would like to investigate whether GNNs with sufficient expressiveness for biconnectivity can also help real-world tasks and benefit the generalization performance as well.
Revised: Secondly , we would like to investigate whether GNNs with sufficient expressiveness for biconnectivity can also help real-world tasks and benefit the generalization performance as well.

Revised: The code and models will be made publicly available at https://github.com/lsj2408/Graphormer-GD .

Original: Synthetic tasks .
Revised: Synthetic tasks .

Original: To test the expressive power of GNNs for biconnectivity metrics, we separately consider two tasks: (i) Cut Vertex Detection and (ii) Cut Edge Detection.
Revised: To test the expressive power of GNNs for biconnectivity metrics, we separately consider two tasks: (i) Cut Vertex Detection and (ii) Cut Edge Detection.

Original: Given a GNN model that outputs node features, we add a learnable prediction head that takes each node feature (or two node features corresponding to each edge) as input and predicts whether it is a cut vertex (cut edge) or not.
Revised: Given a GNN model that outputs node features, we add a learnable prediction head that takes each node feature (or two node features corresponding to each edge) as input and predicts whether it is a cut vertex (cut edge) or not.

Original: The evaluation metric for both tasks is the graph-level accuracy, i.e., given a graph, the model prediction is considered correct only when all the cut vertices/edges are correctly identified.
Revised: The evaluation metric for both tasks is the graph-level accuracy, i.e., given a graph, the model prediction is considered correct only when all the cut vertices/edges are correctly identified.

Original: To make the results convincing, we construct a challenging dataset that comprises various types of hard graphs, including the regular graphs with cut vertices/edges and also Examples C.9 and C. mentioned in Section 3.
Revised: To make the results convincing, we construct a challenging dataset that comprises various types of hard graphs, including the regular graphs with cut vertices/edges and also Examples C.9 and C. mentioned in Section 3.

Original: We also choose several GNN baselines with different levels of expressive power: (i) classic MPNNs (Kipf & Welling, 2017; Veliˇckovi´c et al., 2018; Xu et al., 2019); (ii) Graph Substructure Network (Bouritsas et al., 2022); (iii) Graphormer (Ying et al., 2021a).
Revised: We also choose several GNN baselines with different levels of expressive power: (i) classic MPNNs (Kipf & Welling, 2017; Veliˇckovi´c et al., 2018; Xu et al., 2019); (ii) Graph Substructure Network (Bouritsas et al., 2022); (iii) Graphormer (Ying et al., 2021a).

Original: The details of model configurations, dataset, and training procedure are provided in Appendix F.1.
Revised: The details of model configurations, dataset, and training procedure are provided in Appendix F.1.

Revised: [Table]

Original: The results are presented in Table 2.
Revised: The results are presented in Table 2.

Original: It can be seen that baseline GNNs cannot perfectly solve these synthetic tasks.
Revised: It can be seen that baseline GNNs cannot perfectly solve these synthetic tasks.

Original: In contrast, the Graphormer-GD achieves 100% accuracy on both tasks, implying that it can easily learn biconnectivity metrics even in very difficult graphs.
Revised: In contrast, the Graphormer-GD achieves 100% accuracy on both tasks, implying that it can easily learn biconnectivity metrics even in very difficult graphs.

Original: Moreover, while using only SPD suffices to identify cut edges, it is still necessary to further incorporate RD to identify cut vertices.
Revised: Moreover, while using only SPD suffices to identify cut edges, it is still necessary to further incorporate RD to identify cut vertices.

Original: This is consistent with our theoretical results in Theorems 4.1, 4.2 and 4.4.
Revised: This is consistent with our theoretical results in Theorems 4.1, 4.2 and 4.4.

Original: Real-world tasks .
Revised: Real-world tasks .

Original: We further study the empirical performance of our Graphormer-GD on the realworld benchmark: ZINC from Benchmarking-GNNs (Dwivedi et al., 2020).
Revised: We further study the empirical performance of our Graphormer-GD on the realworld benchmark: ZINC from Benchmarking-GNNs (Dwivedi et al., 2020).

Original: To show the scalability of Graphormer-GD, we train our models on both ZINC-Full (consisting of 250K molecular graphs) and ZINC-Subset (12K selected graphs).
Revised: To show the scalability of Graphormer-GD, we train our models on both ZINC-Full (consisting of 250K molecular graphs) and ZINC-Subset (12K selected graphs).

Original: We comprehensively compare our model with prior expressive GNNs that have been publicly released.
Revised: We comprehensively compare our model with prior expressive GNNs that have been publicly released.

Original: For a fair comparison, we ensure that the parameter budget of both Graphormer-GD and other compared models are around 500K, following Dwivedi et al.
Revised: For a fair comparison, we ensure that the parameter budget of both Graphormer-GD and other compared models are around 500K, following Dwivedi et al.

Original: Details of baselines and settings are presented in Appendix F.2.
Revised: Details of baselines and settings are presented in Appendix F.2.

Original: The results are shown in Table 3, where our score is averaged over four experiments with different seeds.
Revised: The results are shown in Table 3, where our score is averaged over four experiments with different seeds.

Revised: We also list the per-epoch training time of different models on ZINC-subset as well as their model parameters.

Original: It can be seen that Graphormer-GD surpasses  all competitive baselines on the test set of both ZINC-Subset and ZINC-Full.
Revised: It can be seen that Graphormer-GD surpasses or matches all competitive baselines on the test set of both ZINC-Subset and ZINC-Full.

Original: Furthermore, we find that the empirical performance of compared models align with their expressive power measured by graph biconnectivity.
Revised: Furthermore, we find that the empirical performance of compared models align with their expressive power measured by graph biconnectivity.

Original: For example, Subgraph GNNs that are expressive for biconnectivity also consistently outperform classic MPNNs by a large margin.
Revised: For example, Subgraph GNNs that are expressive for biconnectivity also consistently outperform classic MPNNs by a large margin.

Original: Compared with Subgraph GNNs, the main advantage of Graphormer-GD is that it  haslower computational cost and stronger parallelizability while still achieving better performance.
Revised: Compared with Subgraph GNNs, the main advantage of Graphormer-GD is that it is simpler to implement, has stronger parallelizability, while still achieving better performance.

Original: Therefore, we believe our proposed architecture is both effective and efficient and can be well extended to more practical scenarios like drug discovery [Table]
Revised: Therefore, we believe our proposed architecture is both effective and efficient and can be well extended to more practical scenarios like drug discovery.

Original:  CONCLUSION
Revised:  CONCLUSION

Original: [Table] In this paper [Table] we systematically investigate the expressive power of GNNs via the perspective of graph biconnectivity.
Revised: In this paper, we systematically investigate the expressive power of GNNs via the perspective of graph biconnectivity.

Original: Through the novel lens, we gain strong theoretical insights into the power and limits of existing popular GNNs.
Revised: Through the novel lens, we gain strong theoretical insights into the power and limits of existing popular GNNs.

Original: We then introduce the principled GD-WL framework that is fully expressive for all biconnectivity metrics.
Revised: We then introduce the principled GD-WL framework that is fully expressive for all biconnectivity metrics.

Original: We further design the Graphormer-GD architecture that is provably powerful while enjoying practical efficiency and parallelizability.
Revised: We further design the Graphormer-GD architecture that is provably powerful while enjoying practical efficiency and parallelizability.

Original: Experiments on both synthetic and real-world datasets demonstrate the effectiveness of Graphormer-GD.
Revised: Experiments on both synthetic and real-world datasets demonstrate the effectiveness of Graphormer-GD.

Original: There are still many promising directions that have not yet been explored.
Revised: There are still many promising directions that have not yet been explored.

Original: Firstly , it remains an important open problem whether biconnectivity can be solved more efficiently in o ( n 2 ) time using equivariant GNNs.
Revised: Firstly , it remains an important open problem whether biconnectivity can be solved more efficiently in o ( n 2 ) time using equivariant GNNs.

Original: Secondly , in light of the crucial importance of structural (distance) encoding in 
Revised: Secondly , a deep understanding of GD-WL is generally lacking. For example, we conjecture that RD-WL can encode graph spectral (Lim et al., 2022) and is strictly more powerful than SPD-WL in distinguishing general graphs.

Original: Graph Transformers revealed in this paper, it may be interesting to further investigate more expressive structural encoding schemes.
Revised: Thirdly , it may be interesting to further investigate more expressive distance (structural) encoding schemes beyond RD-WL and explore how to encode them in Graph Transformers.

Original: Finally , one can extend biconnectivity to a hierarchy of higherorder variants (e.g., tri-connectivity), which provides a completely different view parallel to the WL hierarchy to study the expressive power and guide designing provably powerful GNNs architectures. 
Revised: Finally , one can extend biconnectivity to a hierarchy of higher-order variants (e.g., tri-connectivity), which provides a completely different view parallel to the WL hierarchy to study the expressive power and guide designing provably powerful GNNs architectures. [Table] A CKNOWLEDGMENTS

Revised: Bohang Zhang is grateful to Ruichen Li for his great help in discussing and checking several of the main results in this paper, including Theorems 3.1, 3.2, 4.1 and C.58.

Original: Appendix Table of Contents
Revised: In particular, after the initial submission, Ruichen Li discovered a simpler proof of Lemma C.28 and helped complete the proof of Theorem C.58. Bohang Zhang would also thank Yiheng Du, Kai Yang amd Ruichen Li for correcting some small mistakes in the proof of Lemmas C.20 and C.45. We also thank all the anonymous reviewers for the careful reviews and the valuable suggestions.

Original: A
Revised: Their help has further enhanced our work. This work is supported by National Key R&D Program of China (2022ZD0114900) and National Science Foundation of China (NSFC62276005) Table of Contents

Original: B The Weisfeiler-Lehman Algorithms and Recently Proposed Variants
Revised: B The Weisfeiler-Lehman Algorithms and Recently Proposed Variants

Original: B.1 1-WL Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: B.1 1-WL Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: B.2 k -FWL Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: B.2 k -FWL Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: B.3 WL with Substructure Counting (SC-WL) . . . . . . . . . . . . . . . . . . . .
Revised: B.3 WL with Substructure Counting (SC-WL) . . . . . . . . . . . . . . . . . . . .

Original: B.4 Equivariant Subgraph Aggregation WL (DSS-WL) . . . . . . . . . . . . . . . .
Revised: B.4 Equivariant Subgraph Aggregation WL (DSS-WL) . . . . . . . . . . . . . . . .

Original: B.5 Generalized Distance WL (GD-WL) . . . . . . . . . . . . . . . . . . . . . . .
Revised: B.5 Generalized Distance WL (GD-WL) . . . . . . . . . . . . . . . . . . . . . . .

Original: C Proof of Theorems
Revised: C Proof of Theorems

Original: C.1 Properties of color refinement algorithms . . . . . . . . . . . . . . . . . . . . .
Revised: C.1 Properties of color refinement algorithms . . . . . . . . . . . . . . . . . . . . .

Original: C.2 Counterexamples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: C.2 Counterexamples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: C.3 Proof of Theorem 3.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: C.3 Proof of Theorem 3.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: C.4 Proof of Theorem 4.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: C.4 Proof of Theorem 4.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: C.5 Proof of Theorem 4.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: C.5 Proof of Theorem 4.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: C.6 Proof of Theorem 4.5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
Revised: C.6 Proof of Theorem 4.5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C

Revised: .7 Regarding distance-regular graphs

Original: D Further Discussions with Prior Works
Revised: D Further Discussions with Prior Works

Original: D.1 Known metrics for measuring the expressive power of GNNs
Revised: D.1 Known metrics for measuring the expressive power of GNNs

Original: D.2 GNNs with Distance encoding
Revised: D.2 GNNs with distance encoding

Original: E Implementation of Generalized Distance Weisfeiler-Lehman
Revised: E Implementation of Generalized Distance Weisfeiler-Lehman

Original: E.1 Preprocessing Shortest Path Distance . . . . . . . . . . . . . . . . . . . . . . .
Revised: E.1 Preprocessing Shortest Path Distance . . . . . . . . . . . . . . . . . . . . . . .

Original: E.2 Preprocessing Resistance Distance . .
Revised: E.2 Preprocessing Resistance Distance . .

Original: E.3 Transformer-based implementation . .
Revised: E.3 Transformer-based implementation . .

Original: F Experimental Details
Revised: F Experimental Details

Original: F.1 Synthetic Tasks . .
Revised: F.1 Synthetic Tasks . .

Original: F.2 Real-world Tasks . .
Revised: F.2 Real-world Tasks . .

Original: F.3 More Tasks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: F.3 More Tasks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: F.4 Efficiency Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Revised: F.4 Efficiency Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Original: A R ECENT ADVANCES IN EXPRESSIVE GNN S
Revised: A R ECENT ADVANCES IN EXPRESSIVE GNN S

Original: Since the seminal works of Xu et al.
Revised: Since the seminal works of Xu et al.

Original: ; Morris et al.
Revised: ; Morris et al.

Original: (2019), extensive studies have devoted to developing new GNN architectures with better expressiveness beyond the 1-WL test.
Revised: (2019), extensive studies have devoted to developing new GNN architectures with better expressiveness beyond the 1-WL test.

Original: These works can be broadly classified into the following categories.
Revised: These works can be broadly classified into the following categories.

Original: Higher-order GNNs .
Revised: Higher-order GNNs .

Original: One straightforward way to design provably more expressive GNNs is inspired by the higher-order WL tests (see Appendix B.2).
Revised: One straightforward way to design provably more expressive GNNs is inspired by the higher-order WL tests (see Appendix B.2).

Original: Instead of performing node feature aggregation, these higher-order GNNs calculate a feature vector for each k -tuple of nodes ( k ≥ 2 ) and perform aggregation between features of different tuples using tensor operations (Morris et al., 2019; Maron et al., 2019b;c;a; Keriven & Peyr´e, 2019; Azizian & Lelarge, 2021; Geerts & Reutter, 2022).
Revised: Instead of performing node feature aggregation, these higher-order GNNs calculate a feature vector for each k -tuple of nodes ( k ≥ 2 ) and perform aggregation between features of different tuples using tensor operations (Morris et al., 2019; Maron et al., 2019b;c;a; Keriven & Peyr´e, 2019; Azizian & Lelarge, 2021; Geerts & Reutter, 2022).

Original: In particular, Maron et al.
Revised: In particular, Maron et al.

Original: (2019a) leveraged equivariant matrix multiplication to design network layers that mimic the 2-FWL aggregation.
Revised: (2019a) leveraged equivariant matrix multiplication to design network layers that mimic the 2-FWL aggregation.

Original: Due to the huge computational cost of higher-order
Revised: Due to the huge computational cost of higher-order

Original: GNNs, several recent works considered improving efficiency by leveraging the sparse and local nature of graphs and designing a “local” version of the k -WL aggregation, which comes at the cost of some expressiveness (Morris et al., 2020; 2022).
Revised: GNNs, several recent works considered improving efficiency by leveraging the sparse and local nature of graphs and designing a “local” version of the k -WL aggregation, which comes at the cost of some expressiveness (Morris et al., 2020; 2022).

Original: The work of Vignac et al.
Revised: The work of Vignac et al.

Original: (2020) can also be seen as a local 2-order GNN and its expressive power is bounded by 3-IGN (Maron et al., 2019c).
Revised: (2020) can also be seen as a local 2-order GNN and its expressive power is bounded by 3-IGN (Maron et al., 2019c).

Original: Substructure-based GNNs .
Revised: Substructure-based GNNs .

Original: Another way to design more expressive GNNs is inspired by studying the failure cases of 1-WL test.
Revised: Another way to design more expressive GNNs is inspired by studying the failure cases of 1-WL test.

Original: In particular, Chen et al.
Revised: In particular, Chen et al.

Original: (2020) pointed out that standard MPNNs cannot detect/count common substructures such as cycles, cliques, and paths.
Revised: (2020) pointed out that standard MPNNs cannot detect/count common substructures such as cycles, cliques, and paths.

Original: Based on this finding,
Revised: Based on this finding,

Original: Bouritsas et al.
Revised: Bouritsas et al.

Original: (2022) designed the Graph Substructure Network (GSN) by incorporating substructure counting into node features using a preprocessing step.
Revised: (2022) designed the Graph Substructure Network (GSN) by incorporating substructure counting into node features using a preprocessing step.

Original: Such an approach was later extended by Barcel ´ o et al.
Revised: Such an approach was later extended by Barcel ´ o et al.

Original: based on homomorphism counting.
Revised: based on homomorphism counting.

Original: Bodnar et al.
Revised: Bodnar et al.

Original: (2021b;a); Thiede et al.
Revised: (2021b;a); Thiede et al.

Original: (2021); Horn et al.
Revised: (2021); Horn et al.

Original: (2022) further developed novel WL aggregation schemes that take into account these substructures (e.g., cycles or cliques).
Revised: (2022) further developed novel WL aggregation schemes that take into account these substructures (e.g., cycles or cliques).

Original: Toenshoff et al.
Revised: Toenshoff et al.

Original: (2021) considered using random walk techniques to generated small substructures.
Revised: (2021) considered using random walk techniques to generate small substructures.

Original: Subgraph GNNs .
Revised: Subgraph GNNs .

Original: In fact, the graphs indistinguishable by 1-WL tend to possess a high degree of symmetry (e.g., see Figure 2).
Revised: In fact, the graphs indistinguishable by 1-WL tend to possess a high degree of symmetry (e.g., see Figure 2).

Original: Based on this observation, a variety of recent approaches sought to break the symmetry by feeding subgraphs into an MPNN.
Revised: Based on this observation, a variety of recent approaches sought to break the symmetry by feeding subgraphs into an MPNN.

Original: To maintain equivariance, a set of subgraphs is generated symmetrically from the original graph using predefined policies, and the final output is aggregated across all subgraphs.
Revised: To maintain equivariance, a set of subgraphs is generated symmetrically from the original graph using predefined policies, and the final output is aggregated across all subgraphs.

Original: There have been several subgraph generation policies in prior works, such as node deletion (Cotta et al., 2021), edge deletion (Bevilacqua et al., 2022), node marking (Papp & Wattenhofer, 2022), and ego-networks (Zhao et al., 2022; Zhang & Li, 2021; You et al., 2021).
Revised: There have been several subgraph generation policies in prior works, such as node deletion (Cotta et al., 2021), edge deletion (Bevilacqua et al., 2022), node marking (Papp & Wattenhofer, 2022), and ego-networks (Zhao et al., 2022; Zhang & Li, 2021; You et al., 2021).

Original: These works also slightly differ in the aggregation schemes.
Revised: These works also slightly differ in the aggregation schemes.

Original: In particular, Bevilacqua et al.
Revised: In particular, Bevilacqua et al.

Original: (2022) developed a unified framework, called ESAN, which includes per-layer aggregation across subgraphs and thus enjoys better expressiveness.
Revised: (2022) developed a unified framework, called ESAN, which includes per-layer aggregation across subgraphs and thus enjoys better expressiveness.

Original: Very recently, Frasca et al.
Revised: Very recently, Frasca et al.

Original: (2022) further extended the framework based on a more relaxed symmetry analysis and proved an upper bound of its expressiveness to be 3-WL.
Revised: (2022) further extended the framework based on a more relaxed symmetry analysis and proved an upper bound of its expressiveness to be 3-WL.

Original: Qian et al.
Revised: Qian et al.

Original: (2022) provided a theoretical analysis of how subgraph
Revised: (2022) provided a theoretical analysis of how subgraph

Original: GNNs relate to k -FWL and also designed an approach to learn policies.
Revised: GNNs relate to k -FWL and also designed an approach to learn policies.

Original: Non-equivariant GNNs .
Revised: Non-equivariant GNNs .

Original: Perhaps one of the simplest way to break the intrinsic symmetry of 1-WL aggregation is to use non-equivariant GNNs.
Revised: Perhaps one of the simplest way to break the intrinsic symmetry of 1-WL aggregation is to use non-equivariant GNNs.

Original: Indeed, Loukas (2020) proved that if each node in a
Revised: Indeed, Loukas (2020) proved that if each node in a

Original: GNN is equipped with a unique identifier, then standard MPNNs can already be Turing universal.
Revised: GNN is equipped with a unique identifier, then standard MPNNs can already be Turing universal.

Original: There have been several works that exploit this idea to build powerful GNNs, such as using port numbering (Sato et al., 2019), relational pooling (Murphy et al., 2019), random features (Sato et al., 2021;
Revised: There have been several works that exploit this idea to build powerful GNNs, such as using port numbering (Sato et al., 2019), relational pooling (Murphy et al., 2019), random features (Sato et al., 2021;

Original: Abboud et al., 2021), or dropout techniques (Papp et al., 2021).
Revised: Abboud et al., 2021), or dropout techniques (Papp et al., 2021).

Original: However, since the resulting architectures cannot fully preserve equivariance, the sample complexity required for training and generalization may not be guaranteed (Garg et al., 2020).
Revised: However, since the resulting architectures cannot fully preserve equivariance, the sample complexity required for training and generalization may not be guaranteed (Garg et al., 2020).

Original: Therefore, in this paper we only focus on analyzing and designing equivariant GNNs.
Revised: Therefore, in this paper we only focus on analyzing and designing equivariant GNNs.

Original: Other approaches .
Revised: Other approaches .

Original: Wijesinghe & Wang (2022); de Haan et al.
Revised: Wijesinghe & Wang (2022); de Haan et al.

Original: (2020) designed novel variants of
Revised: (2020) designed novel variants of

Original: MPNNs based on more powerful neighborhood aggregation schemes that are aware of the local graph structure, rather than simply treating neighboring nodes as a set.
Revised: MPNNs based on more powerful neighborhood aggregation schemes that are aware of the local graph structure, rather than simply treating neighboring nodes as a set.

Original: Li et al.
Revised: Li et al.

Original: ; Velingker et al.
Revised: ; Velingker et al.

Original: (2022) incorporated distance encoding into node/edge features to enhance the expressive power of MPNNs.
Revised: (2022) incorporated distance encoding into node/edge features to enhance the expressive power of MPNNs.

Original: Balcilar et al.
Revised: Balcilar et al.

Original: ; Feldman et al.
Revised: ; Feldman et al.

Original: (2022) utilized spectral information of graphs to achieve better expressiveness beyond 1-WL.
Revised: (2022) utilized spectral information of graphs to achieve better expressiveness beyond 1-WL.

Original: Talak et al.
Revised: Talak et al.

Original: (2021) proposed the Neural Tree Network that performs message passing between higher-order subgraphs instead of node-level aggregation.
Revised: (2021) proposed the Neural Tree Network that performs message passing between higher-order subgraphs instead of node-level aggregation.

Original: Finally, for a comprehensive survey on expressive GNNs, we refer readers to Sato (2020) and Morris et al.
Revised: Finally, for a comprehensive survey on expressive GNNs, we refer readers to Sato (2020) and Morris et al.

Original: B T HE W EISFEILER -L EHMAN A LGORITHMS AND R ECENTLY P ROPOSED V ARIANTS
Revised: B T HE W EISFEILER -L EHMAN A LGORITHMS AND R ECENTLY P ROPOSED V ARIANTS

Original: In this section, we give a precise description on the family of Weisfeiler-Lehman algorithms and several recently proposed variants that are studied in this paper.
Revised: In this section, we give a precise description on the family of Weisfeiler-Lehman algorithms and several recently proposed variants that are studied in this paper.

Original: We first present the classic 1-WL algorithm (Weisfeiler & Leman, 1968) and the more advanced k -FWL (Cai et al., 1992; Morris et al., 2019).
Revised: We first present the classic 1-WL algorithm (Weisfeiler & Leman, 1968) and the more advanced k -FWL (Cai et al., 1992; Morris et al., 2019).

Original: Then we present several recently proposed WL variants, including WL with Substructure
Revised: Then we present several recently proposed WL variants, including WL with Substructure

Original: Counting (SC-WL) (Bouritsas et al., 2022),
Revised: Counting (SC-WL) (Bouritsas et al., 2022),

Original: Overlap Subgraph WL (OS-WL) (Wijesinghe & Wang, 2022), Equivariant Subgraph Aggregation WL (DSS-WL) (Bevilacqua et al., 2022) and Generalized
Revised: Overlap Subgraph WL (OS-WL) (Wijesinghe & Wang, 2022), Equivariant Subgraph Aggregation WL (DSS-WL) (Bevilacqua et al., 2022) and Generalized

Original: Distance WL (GD-WL).
Revised: Distance WL (GD-WL).

Original: Throughout this section, we assume hash :
Revised: Throughout this section, we assume hash :

Original: X → C is an injective hash function that can map “arbitrary objects” to a color in C where C is an abstract set called the color set .
Revised: X → C is an injective hash function that can map “arbitrary objects” to a color in C where C is an abstract set called the color set .

Original: Formally, the domain X comprises all the objects we are interested in:
Revised: Formally, the domain X comprises all the objects we are interested in:

Original: • R ⊂ X and C ⊂ X ; • For any finite multiset M with elements in X , M ∈ X ; • For any tuple c ∈ X k of finite dimension k ∈ N + , c ∈ X .
Revised: • R ⊂ X and C ⊂ X ; • For any finite multiset M with elements in X , M ∈ X ; • For any tuple c ∈ X k of finite dimension k ∈ N + , c ∈ X .

Original: B. 1-WL T EST
Revised: B. 1-WL T EST

Original: Given a graph G =
Revised: Given a graph G =

Original: ( V , E ) , the 1-dimensional Weisfeiler-Lehman algorithm (1-WL), also called the color refinement algorithm, iteratively calculates a color mapping χ G from each vertex v ∈ V to a color χ G ( v ) ∈ C .
Revised: ( V , E ) , the 1-dimensional Weisfeiler-Lehman algorithm (1-WL), also called the color refinement algorithm, iteratively calculates a color mapping χ G from each vertex v ∈ V to a color χ G ( v ) ∈ C .

Original: The pseudo code of 1-WL is presented in Algorithm 1.
Revised: The pseudo code of 1-WL is presented in Algorithm 1.

Original: Intuitively, at the beginning the color of each vertex is initialized to be the same.
Revised: Intuitively, at the beginning the color of each vertex is initialized to be the same.

Original: Then in each iteration, 1-WL algorithm updates each vertex color by combining its own color with the neighborhood color multiset using a hash function.
Revised: Then in each iteration, 1-WL algorithm updates each vertex color by combining its own color with the neighborhood color multiset using a hash function.

Original: This procedure is repeated for a sufficiently large number of iterations T , e.g. T = |V| .
Revised: This procedure is repeated for a sufficiently large number of iterations T , e.g. T = |V| .

Original: Algorithm 1:
Revised: Algorithm 1:

Original: The
Revised: The

Original: Input : Graph G =
Revised: Input : Graph G =

Original: ( V , E ) and the number of iterations T
Revised: ( V , E ) and the number of iterations T

Original: Output: Color mapping χ G : V → C1 Initialize: Pick a fixed (arbitrary) element c0 ∈ C , and let χ 0 G ( v) :
Revised: Output: Color mapping χ G : V → C c v

Original: = c 0 for all v ∈ V2 for t ← 1 to T dofor each v∈ V do χ tG ( v ) :
Revised: V do v do χ tG ( v ) :

Original: = hash (cid:0)
Revised: = hash (cid:0)

Original: χ t − 1 G ( v ) , {{ χ t − 1 G ( u ) : u ∈ N G ( v ) }} (cid:1) 5 Return: χ TG
Revised: χ t − 1 G ( v ) , {{ χ t − 1 G ( u ) : u ∈ N G ( v ) }} (cid:1) 5 Return: χ TG

Original: At each iteration, the color mapping χ tG induces a partition of the vertex set V with an equivalence relation ∼ χ tG defined to be u ∼ χ tG v ⇐⇒ χ tG ( u )
Revised: At each iteration, the color mapping χ tG induces a partition of the vertex set V with an equivalence relation ∼ χ tG defined to be u ∼ χ tG v ⇐⇒ χ tG ( u )

Original: =
Revised: =

Original: χ tG ( v ) for u, v ∈ V .
Revised: χ tG ( v ) for u, v ∈ V .

Original: We call each equivalence class a color class with an associated color c ∈ C , denoted as ( χ t G ) − 1 ( c ) :
Revised: We call each equivalence class a color class with an associated color c ∈ C , denoted as ( χ t G ) − 1 ( c ) :

Original: = { v ∈ V : χ t G ( v ) =
Revised: = { v ∈ V : χ t G ( v ) =

Original: c } .
Revised: c } .

Original: The corresponding partition is then denoted as P t G = { ( χ t G ) − 1 ( c ) : c ∈ C t G } where C t G :=
Revised: The corresponding partition is then denoted as P t G = { ( χ t G ) − 1 ( c ) : c ∈ C t G } where C t G :=

Original: { χ t G ( v ) : v ∈ V} is the color set containing all the presented colors of vertices in G .
Revised: { χ t G ( v ) : v ∈ V} is the color set containing all the presented colors of vertices in G .

Original: An important observation is that each 1-WL iteration refines the partition P tG to a finer partition
Revised: An important observation is that each 1-WL iteration refines the partition P tG to a finer partition

Original: P t +1 G , because for any u, v ∈ V , u ∼ χ t +1 G v implies u ∼ χ tG v .
Revised: P t +1 G , because for any u, v ∈ V , u ∼ χ t +1 G v implies u ∼ χ tG v .

Original: Since the number of vertices |V| is finite, there must exist an iteration T stable < |V| such that P T stable G = P T stable +1 G .
Revised: Since the number of vertices |V| is finite, there must exist an iteration T stable < |V| such that P T stable G = P T stable +1 G .

Original: It follows that
Revised: It follows that

Original: P tG = P T stable G for all t ≥ T stable , i.e. the partition stabilizes.
Revised: P tG = P T stable G for all t ≥ T stable , i.e. the partition stabilizes.

Original: We thus denote P G :=
Revised: We thus denote P G :=

Original: P T stable G as the stable partition induced by the 1-WL algorithm, and denote χ G as any stable color mapping (i.e. by picking any χ tG with t ≥ T stable ).
Revised: P T stable G as the stable partition induced by the 1-WL algorithm, and denote χ G as any stable color mapping (i.e. by picking any χ tG with t ≥ T stable ).

Original: We can similarly define the inverse mapping χ − 1 G .
Revised: We can similarly define the inverse mapping χ − 1 G .

Original: The mapping χ G serves as a node feature extractor so that χ G ( v ) is the representation of node v ∈ V .
Revised: The mapping χ G serves as a node feature extractor so that χ G ( v ) is the representation of node v ∈ V .

Original: Correspondingly, the multiset {{ χ G ( v ) : v ∈ V}} can serve as the representation of graph G .
Revised: Correspondingly, the multiset {{ χ G ( v ) : v ∈ V}} can serve as the representation of graph G .

Original: The 1-WL algorithm can be used to distinguish whether two graphs G and H are isomorphic, by comparing their graph representations {{ χ G ( v ) :
Revised: The 1-WL algorithm can be used to distinguish whether two graphs G and H are isomorphic, by comparing their graph representations {{ χ G ( v ) :

Original: v ∈ V}} and {{ χ H ( v ) : v ∈ V}} .
Revised: v ∈ V}} and {{ χ H ( v ) : v ∈ V}} .

Original: If the two multisets are not equivalent, then G and H are clearly non-isomorphic.
Revised: If the two multisets are not equivalent, then G and H are clearly non-isomorphic.

Original: Thus 1-WL is a necessary condition to test graph isomorphism.
Revised: Thus 1-WL is a necessary condition to test graph isomorphism.

Original: Nevertheless, the 1-WL test fails when {{ χ G ( v ) : v ∈ V}} = {{ χ H ( v ) : v ∈ V}} but G and H are still non-isomorphic (see Figure 2 for a counterexample).
Revised: Nevertheless, the 1-WL test fails when {{ χ G ( v ) : v ∈ V}} = {{ χ H ( v ) : v ∈ V}} but G and H are still non-isomorphic (see Figure 2 for a counterexample).

Original: This motivates the more powerful higher-order WL tests, which are illustrated in the next subsection.
Revised: This motivates the more powerful higher-order WL tests, which are illustrated in the next subsection.

Original: B. k -FWL T EST
Revised: B. k -FWL T EST

Original: In this section, we present a family of algorithms called the k -dimensional Folklore WeisfeilerLehman algorithms ( k -FWL).
Revised: In this section, we present a family of algorithms called the k -dimensional Folklore WeisfeilerLehman algorithms ( k -FWL).

Original: Instead of calculating a node color mapping, k -FWL computes a color mapping on each k -tuple of nodes.
Revised: Instead of calculating a node color mapping, k -FWL computes a color mapping on each k -tuple of nodes.

Original: The pseudo code of k -FWL ( k ≥ 2 ) is presented in Algorithm 2.
Revised: The pseudo code of k -FWL ( k ≥ 2 ) is presented in Algorithm 2.

Original: Algorithm
Revised: Algorithm

Original: Input : Graph G =
Revised: Input : Graph G =

Original: ( V , E ) and the number of iterations T
Revised: ( V , E ) and the number of iterations T

Original: Output: Color mapping χ G : V k
Revised: Output: Color mapping χ G : V k

Original: → C 1 Initialize: Pick three fixed different elements c 0 , c 1 , c node ∈ C , let χ 0 G ( v ) :
Revised: → C 1 Initialize: Pick three fixed different elements c 0 , c 1 , c node ∈ C , let χ 0 G ( v ) :

Original: = hash(vec
Revised: = hash(vec

Original: ( A v ))
Revised: ( A v ))

Original: for each v ∈ V k where A v ∈ C k × k is a matrix with elementsA [Equation] =
Revised: for each v ∈ V k where A v ∈ C k × k is a matrix with elements

Original: [Equation] if v [Equation] = v j cif v 
Revised: A v ij = (cid:40) c node if v i = v j cif v i ̸

Original: [Equation]

Original: ̸ = v [Equation] and { v i , v [Equation]
Revised: = v j and { v i , v j } / ∈ E cif v i ̸

Original: [Equation]

Original: E c [Equation] if v i ̸ = v j and { v i , v j } ∈ E (6) 2 for t ← 1 to T do for each v ∈ V k do χ tG ( v ) :
Revised: = v j and { v i , v j } ∈ E (6) 2 for t ← 1 to T do for each v ∈ V k do χ tG ( v ) :

Original: = hash (cid:0)
Revised: = hash (cid:0)

Original: χ t − 1 G ( v ) , {{ ( χ t − 1 G ( N 1 ( v , u )) , · · · , χ t − 1 G ( N k ( v , u ))) : u ∈ V}} (cid:1) where N i ( v , u ) =
Revised: χ t − 1 G ( v ) , {{ ( χ t − 1 G ( N 1 ( v , u )) , · · · , χ t − 1 G ( N k ( v , u ))) : u ∈ V}} (cid:1) where N i ( v , u ) =

Original: ( v 1 , · · · , v i − 1 , u, v i +1 ,
Revised: ( v 1 , · · · , v i − 1 , u, v i +1 ,

Original: · · · , v k ) 6 Return: χ TG
Revised: · · · , v k ) 6 Return: χ TG

Original: Intuitively, at the beginning, the color of each vertex tuple v encodes the full structure (i.e. isomophism type) of the subgraph induced by the ordered vertex set { v i : i ∈ [ k ] } , by hashing the “adjacency” matrix
Revised: Intuitively, at the beginning, the color of each vertex tuple v encodes the full structure (i.e. isomophism type) of the subgraph induced by the ordered vertex set { v i : i ∈ [ k ] } , by hashing the “adjacency” matrix

Original: A v defined in (6).
Revised: A v defined in (6).

Original: Then in each iteration, k -FWL algorithm updates the color of each vertex tuple by combining its own color with the “neighborhood” color using a hash function.
Revised: Then in each iteration, k -FWL algorithm updates the color of each vertex tuple by combining its own color with the “neighborhood” color using a hash function.

Original: Here, the neighborhood of a tuple v is all the tuples that differ v by exactly one element.
Revised: Here, the neighborhood of a tuple v is all the tuples that differ v by exactly one element.

Original: These k × |V| neighborhood colors are grouped into a multiset of size |V| where each element is a k -tuple.
Revised: These k × |V| neighborhood colors are grouped into a multiset of size |V| where each element is a k -tuple.

Original: Finally, the update procedure is repeated for a sufficiently large number of iterations T , e.g.
Revised: Finally, the update procedure is repeated for a sufficiently large number of iterations T , e.g.

Original: T = |V| k .
Revised: T = |V| k .

Original: Simiar to 1-WL, the k -FWL color mapping χ tG induces a partition of the set of vertex k -tuples
Revised: Simiar to 1-WL, the k -FWL color mapping χ tG induces a partition of the set of vertex k -tuples

Original: V k , and each k -FWL iteration refines the partition of the previous iteration.
Revised: V k , and each k -FWL iteration refines the partition of the previous iteration.

Original: Since the number of vertex k -tuples |V| k is finite, there must exist an iteration T stable < |V| k such that the partition no longer changes after t ≥ T stable .
Revised: Since the number of vertex k -tuples |V| k is finite, there must exist an iteration T stable < |V| k such that the partition no longer changes after t ≥ T stable .

Original: We denote the stable color mapping as χ G by picking any χ tG with t ≥ T stable .
Revised: We denote the stable color mapping as χ G by picking any χ tG with t ≥ T stable .

Original: The k -FWL algorithm can be used to distinguish whether two graphs G and H are isomorphic, by comparing their graph representations {{ χ G ( v ) :
Revised: The k -FWL algorithm can be used to distinguish whether two graphs G and H are isomorphic, by comparing their graph representations {{ χ G ( v ) :

Original: v ∈ V k }} and {{ χ H ( v ) : v ∈ V k }} .
Revised: v ∈ V k }} and {{ χ H ( v ) : v ∈ V k }} .

Original: It has been proved that k -FWL is strictly more powerful than 1-WL in distinguishing non-isomorphic graphs, and ( k + 1) -FWL is strictly more powerful than k -FWL for all k ≥ 2 (Cai et al., 1992).
Revised: It has been proved that k -FWL is strictly more powerful than 1-WL in distinguishing non-isomorphic graphs, and ( k + 1) -FWL is strictly more powerful than k -FWL for all k ≥ 2 (Cai et al., 1992).

Original: Moreover, the k -FWL algorithm can also be used to extract node representations as with 1-WL.
Revised: Moreover, the k -FWL algorithm can also be used to extract node representations as with 1-WL.

Original: To do this, we can simply define χ G ( v ) :
Revised: To do this, we can simply define χ G ( v ) :

Original: = χ G ( v, · · · , v ) as the vertex color of the k -FWL algorithm (without abuse of notation), which induces a partition P G over vertex set V .
Revised: = χ G ( v, · · · , v ) as the vertex color of the k -FWL algorithm (without abuse of notation), which induces a partition P G over vertex set V .

Original: It has been shown that this partition is finer than the partition induces by 1-WL, and also the vertex partition induced by ( k + 1) -FWL is finer than that of k -FWL (Kiefer, 2020).
Revised: It has been shown that this partition is finer than the partition induces by 1-WL, and also the vertex partition induced by ( k + 1) -FWL is finer than that of k -FWL (Kiefer, 2020).

Original: B. WL WITH S UBSTRUCTURE C OUNTING (SC-WL)
Revised: B. WL WITH S UBSTRUCTURE C OUNTING (SC-WL)

Original: Recently, Bouritsas et al.
Revised: Recently, Bouritsas et al.

Original: (2022) proposed a variant of the 1-WL algorithm by incorporating the socalled substructure counting into WL aggregation procedure.
Revised: (2022) proposed a variant of the 1-WL algorithm by incorporating the socalled substructure counting into WL aggregation procedure.

Original: This yields a algorithm that is provably powerful than the original 1-WL test.
Revised: This yields a algorithm that is provably powerful than the original 1-WL test.

Original: To describe the algorithm, we first need the notation of automorphism group .
Revised: To describe the algorithm, we first need the notation of automorphism group .

Original: Given a graph H =
Revised: Given a graph H =

Original: ( V H , E H ) , an automorphism of H is a bijective mapping f : V H
Revised: ( V H , E H ) , an automorphism of H is a bijective mapping f : V H

Original: → V H such that for any two vertices u, v ∈ V H , { u, v } ∈ E H ⇐⇒ { f ( u ) , f ( v ) } ∈ E H .
Revised: → V H such that for any two vertices u, v ∈ V H , { u, v } ∈ E H ⇐⇒ { f ( u ) , f ( v ) } ∈ E H .

Original: It follows that all automorphisms of H form a group under function composition, which is called the automorphism group and denoted as
Revised: It follows that all automorphisms of H form a group under function composition, which is called the automorphism group and denoted as

Original: Aut( H ) .
Revised: Aut( H ) .

Original: The automorphism group Aut( H ) yields a partition of the vertex set V , called orbits .
Revised: The automorphism group Aut( H ) yields a partition of the vertex set V , called orbits .

Original: Formally, given a vertex v ∈ V H , define its orbit Orb H ( v ) = { u ∈ V H : ∃ f ∈ Aut( H ) , f ( u ) = v } .
Revised: Formally, given a vertex v ∈ V H , define its orbit Orb H ( v ) = { u ∈ V H : ∃ f ∈ Aut( H ) , f ( u ) = v } .

Original: The set of all orbits H \ Aut( H ) :
Revised: The set of all orbits H \ Aut( H ) :

Original: = { Orb H ( v ) : v ∈ V H } is called the quotient of the automorphism.
Revised: = { Orb H ( v ) : v ∈ V H } is called the quotient of the automorphism.

Original: Denote d H =
Revised: Denote d H =

Original: | H \ Aut( H ) | and denote the elements in H \ Aut( H ) as {O V H,i }
Revised: | H \ Aut( H ) | and denote the elements in H \ Aut( H ) as {O V H,i }

Original: d H i =1 .
Revised: d H i =1 .

Original: We are now ready to describe the procedure of SC-WL.
Revised: We are now ready to describe the procedure of SC-WL.

Original: Pre-processing .
Revised: Pre-processing .

Original: Depending on the tasks, one first specify a set of (small) connected graphs H =
Revised: Depending on the tasks, one first specify a set of (small) connected graphs H =

Original: { H 1 , · · · , H k } , which will be used for sub-structure counting in the input graph G .
Revised: { H 1 , · · · , H k } , which will be used for sub-structure counting in the input graph G .

Original: Popular choices of these small graphs are cycles of different lengths (e.g., triangle or square) and cliques.
Revised: Popular choices of these small graphs are cycles of different lengths (e.g., triangle or square) and cliques.

Original: Given a graph G =
Revised: Given a graph G =

Original: ( V G , E G ) , for each vertex v ∈ V G and each graph H ∈ H , the following quantities are calculated:
Revised: ( V G , E G ) , for each vertex v ∈ V G and each graph H ∈ H , the following quantities are calculated:

Original: [Equation]
Revised: [Equation]

Original: where f G [ S ] →V
Revised: where f G [ S ] →V

Original: H is any isomorphism that maps the vertices of graph G [ S ] to those of graph H .
Revised: H is any isomorphism that maps the vertices of graph G [ S ] to those of graph H .

Original: Intuitively, x V H,i ( v ) counts the number of induced subgraphs of G that is isomorphic to H and contains node v , such that the orbit of v is similar to the orbit O V H,i .
Revised: Intuitively, x V H,i ( v ) counts the number of induced subgraphs of G that is isomorphic to H and contains node v , such that the orbit of v is similar to the orbit O V H,i .

Original: The counts corresponding to different orbits O V H,i and different graphs H are finally combined and concatenated into a vector:
Revised: The counts corresponding to different orbits O V H,i and different graphs H are finally combined and concatenated into a vector:

Original: [Equation]
Revised: [Equation]

Original: where the dimension of x V ( v ) is D=
Revised: where the dimension of x V ( v ) is D

Revised: = (cid:80)

Original: [Equation]
Revised: [Equation]

Original: Message Passing .
Revised: Message Passing .

Original: The message passing procedure is similar to Algorithm 1, except that the aggregation formula (Line 4) is replaced by the following update rule:
Revised: The message passing procedure is similar to Algorithm 1, except that the aggregation formula (Line 4) is replaced by the following update rule:

Original: [Equation]
Revised: [Equation]

Original: which incorporates the substructure counts (7, 8).
Revised: which incorporates the substructure counts (7, 8).

Original: Note that the update rule (9) is slightly simpler than the original paper (Bouritsas et al., 2022, Section 3.2), but the expressive power of the two formulations are the same.
Revised: Note that the update rule (9) is slightly simpler than the original paper (Bouritsas et al., 2022, Section 3.2), but the expressive power of the two formulations are the same.

Original: Finally, we note that the above procedure counts substructures and calculates features x V for each vertex of G .
Revised: Finally, we note that the above procedure counts substructures and calculates features x V for each vertex of G .

Original: One can similarly consider calculating substructure counts for each edge of G , and the conclusion in this paper (Theorem 3.1) still holds.
Revised: One can similarly consider calculating substructure counts for each edge of G , and the conclusion in this paper (Theorem 3.1) still holds.

Original: Please refer to Bouritsas et al.
Revised: Please refer to Bouritsas et al.

Original: for more details on how to calculate edge features.
Revised: for more details on how to calculate edge features.

Original: B. E QUIVARIANT S UBGRAPH A GGREGATION WL (DSS-WL)
Revised: B. E QUIVARIANT S UBGRAPH A GGREGATION WL (DSS-WL)

Original: Recently, Bevilacqua et al.
Revised: Recently, Bevilacqua et al.

Original: (2022) developd a new type of graph neural networks, called Equivariant
Revised: (2022) developd a new type of graph neural networks, called Equivariant

Original: Subgraph Aggregation Networks, as well as a new WL variant named DSS-WL.
Revised: Subgraph Aggregation Networks, as well as a new WL variant named DSS-WL.

Original: Given a graph
Revised: Given a graph

Original: G =
Revised: G =

Original: ( V , E ) , DSS-WL first generates a bag of graphs B πG = {{ G 1 , · · · , G m }} which share the vertices, i.e. G i
Revised: ( V , E ) , DSS-WL first generates a bag of graphs B πG = {{ G 1 , · · · , G m }} which share the vertices, i.e. G i

Original: =
Revised: =

Original: ( V , E i ) , but differ in the edge sets E i .
Revised: ( V , E i ) , but differ in the edge sets E i .

Original: Here π denotes the graph generation policy which determines the edge set E i for each graph G i .
Revised: Here π denotes the graph generation policy which determines the edge set E i for each graph G i .

Original: The initial coloring χ 0 G i ( v ) for each node v ∈ V in graph G i is also determined by π and can be different across different nodes and graphs.
Revised: The initial coloring χ 0 G i ( v ) for each node v ∈ V in graph G i is also determined by π and can be different across different nodes and graphs.

Original: In each iteration, the algorithm refines the color of each node by jointly aggregating its neighboring colors in the own graph and across different graphs.
Revised: In each iteration, the algorithm refines the color of each node by jointly aggregating its neighboring colors in the own graph and across different graphs.

Original: This procedure is repeated for a sufficiently large iterations T to obtain the stable color mappings χ G i and χ G .
Revised: This procedure is repeated for a sufficiently large iterations T to obtain the stable color mappings χ G i and χ G .

Original: The pseudo code of DSS-WL is presented in Algorithm 3.
Revised: The pseudo code of DSS-WL is presented in Algorithm 3.

Original: The key component in the DSS-WL algorithm is the graph generation policy π which must maintain symmetry , i.e., be equivairant under permutation of the vertex set.
Revised: The key component in the DSS-WL algorithm is the graph generation policy π which must maintain symmetry , i.e., be equivairant under permutation of the vertex set.

Original: We list several common choices below:
Revised: We list several common choices below:

Original: • Node marking policy π = π NM .
Revised: • Node marking policy π = π NM .

Original: In this policy, we have B πG = {{ G v : v ∈ V}} where G v = G , i.e., there are |V| graphs in B πG whose structures are the completely the same.
Revised: In this policy, we have B πG = {{ G v : v ∈ V}} where G v = G , i e., there are |V| graphs in B πG whose structures are the completely the same.

Original: The difference, however, lies in the initial coloring which marks the special node v in the following way: χ 0 G v ( v ) =
Revised: The difference, however, lies in the initial coloring which marks the special node v in the following way: χ 0 G v ( v ) =

Original: c 1 and χ 0 G v ( u ) =
Revised: c 1 and χ 0 G v ( u ) =

Original: c 0 for other nodes u ̸ = v , where c 0 , c 1 ∈ C are two different colors.
Revised: c 0 for other nodes u ̸ = v , where c 0 , c 1 ∈ C are two different colors.

Original: • Node deletion policy π = π ND .
Revised: • Node deletion policy π = π ND .

Original: The bag of graphs for this policy is also defined as B πG = {{ G v : v ∈ V}} , but each graph G v = ( V , E v ) has a different edge set E v :=
Revised: The bag of graphs for this policy is also defined as B πG = {{ G v : v ∈ V}} , but each graph G v = ( V , E v ) has a different edge set E v :=

Original: E\{{ v, w } : w ∈ N G ( v ) } .
Revised: E\{{ v, w } : w ∈ N G ( v ) } .

Original: Intuitively, it removes all edges that connects to node v and thus makes v an isolated node.
Revised: Intuitively, it removes all edges that connects to node v and thus makes v an isolated node.

Original: The initial coloring is chosen as a constant χ 0 G i ( v ) =
Revised: The initial coloring is chosen as a constant χ 0 G i ( v ) =

Original: c 0 for all v ∈ V and G i ∈ B π G for some fixed color c 0 ∈ C .
Revised: c 0 for all v ∈ V and G i ∈ B π G for some fixed color c 0 ∈ C .

Original: Input : graph π
Revised: Input : Graph G V

Revised: E ) , the number iterations T , and graph selection policy π

Original: Output: 
Revised: Output: Color χ

Original:  C1 Initialize to policyπ 2 Let χ 0 G ( v ) : =
Revised: : V → C policy 2 Let χ 0 G ( v ) :=

Original: hash (cid:0) {{ χ tG i ( v ) :
Revised: hash (cid:0) {{ χ tG i ( v ) :

Original: i ∈ [ m ] }} (cid:1) for each v ∈ V 3 for t ← 1 to T do for each v ∈ V do for i ← 1 to m do χ tG i ( v ) :
Revised: i ∈ [ m ] }} (cid:1) for each v ∈ V 3 for t ← 1 to T do for each v ∈ V do for i ← 1 to m do χ tG i ( v ) :

Original: = hash (cid:0)
Revised: = hash (cid:0)

Original: χ t − 1 G i ( v ) , {{ χ t − 1 G i ( u ) : u ∈ N G i ( v ) }} , χ t − 1 G ( v ) , {{ χ t − 1 G ( u ) : u ∈ N G ( v ) }} (cid:1) χ tG ( v ) := hash (cid:0) {{ χ tG i ( v ) : i ∈ [ m ] }} (cid:1) 

Revised: χ t − 1 G i ( v ) , {{ χ t − 1 G i ( u ) : u ∈ N G i ( v ) }} , χ t − 1 G ( v ) , {{ χ t − 1 G ( u ) : u ∈ N G ( v ) }} (cid:1) χ tG ( v ) := hash (cid:0) {{ χ tG i ( v ) : i ∈ [ m ] }} (cid:1)

Original: Return: χ TG• Ego network policy π= π
Revised: Return: χ TG Ego network policy π

Revised: = π EGO( k ) .

Original: In this policy, we also have B π G = {{ G v : v ∈ V}} , G v =
Revised: In this policy, we also have B π G = {{ G v : v ∈ V}} , G v =

Original: ( V , E v ) .
Revised: V , E v ) .

Original: The edge set E v is defined as E v := {{ u, w } ∈ E : dis G ( u, v ) ≤ k, dis G ( w, v ) ≤ k } , which corresponds to a subgraph containing all the k -hop neighbors of v and isolating other nodes.
Revised: The edge set E v is defined as E v := {{ u, w } ∈ E : dis G ( u, v ) ≤ k, dis G ( w, v ) ≤ k } , which corresponds to a subgraph containing all the k -hop neighbors of v and isolating other nodes.

Original: The initial coloring is chosen as χ 0 G i ( v ) =
Revised: The initial coloring is chosen as χ 0 G i ( v ) =

Original: c 0 for all v ∈ V and Gi
Revised: c 0 for all v ∈ V and G

Original:  ∈ B πG where c 0 ∈ C is a constant.
Revised: i ∈ B πG where c 0 ∈ C is a constant.

Original: One can also consider the ego network policy with marking π = π EGOM( k ) , by marking the initial color of the special node v for each G v .
Revised: One can also consider the ego network policy with marking π = π EGOM( k ) , by marking the initial color of the special node v for each G v .

Original: We note that for all the above policies, |B πG | = |V| .
Revised: We note that for all the above policies, |B πG | = |V| .

Original: There are other choices such as the edge deletion policy (Bevilacqua et al., 2022), but we do not discuss them in this paper.
Revised: There are other choices such as the edge deletion policy (Bevilacqua et al., 2022), but we do not discuss them in this paper.

Original: A straightforward analysis yields that DSS-WL with any above policy is strictly powerful than the classic 1-WL algorithm.
Revised: A straightforward analysis yields that DSS-WL with any above policy is strictly powerful than the classic 1-WL algorithm.

Original: Also, node marking policy has been shown to be not less powerful than the node deletion policy (Papp & Wattenhofer, 2022).
Revised: Also, node marking policy has been shown to be not less powerful than the node deletion policy (Papp & Wattenhofer, 2022).

Original: Finally, we highlight that Bevilacqua et al.
Revised: Finally, we highlight that Bevilacqua et al.

Original: ; Cotta et al.
Revised: ; Cotta et al.

Original: (2021) also proposed a weaker version of DSS-WL, called the DS-WL algorithm.
Revised: (2021) also proposed a weaker version of DSS-WL, called the DS-WL algorithm.

Original: The difference is that for DS-WL, Lines 6 and 7 in
Revised: The difference is that for DS-WL, Lines 6 and 7 in

Original: Algorithm 3 are replaced by a simple 1-WL aggregation:
Revised: Algorithm 3 are replaced by a simple 1-WL aggregation:

Original: [Equation]
Revised: [Equation]

Original: However, the original formulation of DS-WL (Bevilacqua et al., 2022) only outputs a graph representation {{{{ χ G i ( v ) : v ∈ V}} : G i ∈ B πG }} rather than outputs each node color, which does not suit the node-level tasks (e.g., finding cut vertices).
Revised: However, the original formulation of DS-WL (Bevilacqua et al., 2022) only outputs a graph representation {{{{ χ G i ( v ) : v ∈ V}} : G i ∈ B πG }} rather than outputs each node color, which does not suit the node-level tasks (e.g., finding cut vertices).

Original: Nevertheless, there are simple adaptations that makes DS-WL output a color mapping χ G .
Revised: Nevertheless, there are simple adaptations that makes DS-WL output a color mapping χ G .

Original: We will study these adaptations in Appendix C.2 (see the paragraph above Proposition C.16) and discuss their limitations compared with DSS-WL.
Revised: We will study these adaptations in Appendix C.2 (see the paragraph above Proposition C.16) and discuss their limitations compared with DSS-WL.

Original: B. G ENERALIZED D ISTANCE WL (GD-WL)
Revised: B. G ENERALIZED D ISTANCE WL (GD-WL)

Original: In this paper, we study a new variant of the color refinement algorithm, called the Generalized Distance WL (GD-WL).
Revised: In this paper, we study a new variant of the color refinement algorithm, called the Generalized Distance WL (GD-WL).

Original: The complete algorithm is described below.
Revised: The complete algorithm is described below.

Original: As a special case, when choosing d G = dis G , the resulting algorithm is called the Shortest Path Distance WL (SPD-WL), which is strictly powerful than the classic 1-WL.
Revised: As a special case, when choosing d G = dis G , the resulting algorithm is called the Shortest Path Distance WL (SPD-WL), which is strictly powerful than the classic 1-WL.

Original: Algorithm 4: The Genealized Distance Weisfeiler-Lehman Algorithm
Revised: Algorithm 4: The Genealized Distance Weisfeiler-Lehman Algorithm

Original: Input : Graph G =
Revised: Input : Graph G =

Original: ( V , E ) , distance metric d G : V × V → R + , and the number of iterations T
Revised: ( V , E ) , distance metric d G : V × V → R + , and the number of iterations T

Original: Output: Color mapping χ G : V → C χ tG ( v ) : = hash (cid:0) {{ ( d G ( v, u ) , χ t − 1 G ( u )) : u ∈ V}} (cid:1) 5{+
+} Return: χ TG
Revised: Output: Color mapping χ G : V → C χ tG ( v ) := hash (cid:0) {{ ( d G ( v, u ) , χ t − 1 G ( u )) : u ∈ V}} (cid:1) {+
+} Return: χ TG

Original: C P ROOF OF T HEOREMS
Revised: C P ROOF OF T HEOREMS

Original: This section provides all the missing proofs in this paper.
Revised: This section provides all the missing proofs in this paper.

Original: For the convenience of reading, we will restate each theorem before giving a proof.
Revised: For the convenience of reading, we will restate each theorem before giving a proof.

Original: C. P ROPERTIES OF COLOR REFINEMENT ALGORITHMS
Revised: C. P ROPERTIES OF COLOR REFINEMENT ALGORITHMS

Original: In this subsection, we first derive several important properties that are shared by a general class of color refinement algorithms.
Revised: In this subsection, we first derive several important properties that are shared by a general class of color refinement algorithms.

Original: They will serve as key lemmas in our subsequent proofs.
Revised: They will serve as key lemmas in our subsequent proofs.

Original: Here, a general color refinement algorithm takes a graph G =
Revised: Here, a general color refinement algorithm takes a graph G =

Original: ( V G , E G ) as input and calculates a color mapping χ G : V G → C .
Revised: ( V G , E G ) as input and calculates a color mapping χ G : V G → C .

Original: We first define a concept called the WL-condition .
Revised: We first define a concept called the WL-condition .

Original: Definition C.1.
Revised: Definition C.1.

Original: A color mapping χ G : V G → C is said to satisfy the WL-condition if for any two vertices u, v with the same color (i.e. χ G ( u ) =
Revised: A color mapping χ G : V G → C is said to satisfy the WL-condition if for any two vertices u, v with the same color (i.e. χ G ( u ) =

Original: χ G ( v ) ) and any color c ∈ C ,
Revised: χ G ( v ) ) and any color c ∈ C ,

Original: [Equation]
Revised: [Equation]

Original: where χ − 1 G is the inverse mapping of χ G .
Revised: where χ − 1 G is the inverse mapping of χ G .

Original: Remark C.2.
Revised: Remark C.2.

Original: The WL-condition can be further generalized to handle two graphs.
Revised: The WL-condition can be further generalized to handle two graphs.

Original: Let χ G : V G → C and χ H : V H
Revised: Let χ G : V G → C and χ H : V H

Original: → C be two color mappings obtained by applying the same color refinement algorithm for graphs G and H , respectively.
Revised: → C be two color mappings obtained by applying the same color refinement algorithm for graphs G and H , respectively.

Original: χ G and χ H are said to jointly satisfy the WL-condition , if for any two vertices u ∈ V G and v ∈ V H with the same color ( χ G ( u ) =
Revised: χ G and χ H are said to jointly satisfy the WL-condition , if for any two vertices u ∈ V G and v ∈ V H with the same color ( χ G ( u ) =

Original: χ H ( v ) ) and any color c ∈ C ,
Revised: χ H ( v ) ) and any color c ∈ C ,

Original: [Equation]
Revised: [Equation]

Original: It clearly implies Definition C.1 by choosing G = H .
Revised: It clearly implies Definition C.1 by choosing G = H .

Original: It is easy to see that the classic 1-WL algorithm (Algorithm 1) satisfies the WL-condition.
Revised: It is easy to see that the classic 1-WL algorithm (Algorithm 1) satisfies the WL-condition.

Original: In fact, many of the presented algorithms in this paper satisfy such a condition as we will show below, such as DSS-WL (Algorithm 3), SPD-WL (Algorithm 4 with d G = dis G ), and k -FWL (Algorithm 2).
Revised: In fact, many of the presented algorithms in this paper satisfy such a condition as we will show below, such as DSS-WL (Algorithm 3), SPD-WL (Algorithm 4 with d G = dis G ), and k -FWL (Algorithm 2).

Original: Proposition C.3.
Revised: Proposition C.3.

Original: Consider the DSS-WL algorithm (Algorithm 4) with arbitrary graph selection policy π .
Revised: Consider the DSS-WL algorithm (Algorithm 4) with arbitrary graph selection policy π .

Original: Let χ G and χ H be the color mappings for graphs G and H , and let {{ χ G i : i ∈ [ m G ] }} and {{ χ H i :
Revised: Let χ G and χ H be the color mappings for graphs G and H , and let {{ χ G i : i ∈ [ m G ] }} and {{ χ H i :

Original: i ∈ [ m H ] }} be the color mapping for subgraphs generated by π .
Revised: i ∈ [ m H ] }} be the color mapping for subgraphs generated by π .

Original: Then,
Revised: Then,

Original: • χ G and χ H jointly satisfy the WL-condition; • χ G i and χ
Revised: • χ G and χ H jointly satisfy the WL-condition; • χ G i and χ

Original: H j jointly satisfy the WL-condition for any i ∈ [ m G ] and j ∈ [ m H ] .
Revised: H j jointly satisfy the WL-condition for any i ∈ [ m G ] and j ∈ [ m H ] .

Original: Proof.
Revised: Proof.

Original: We first prove the second bullet of Proposition C.3.
Revised: We first prove the second bullet of Proposition C.3.

Original: By definition of the DSS-WL aggregation procedure (Line 6 in Algorithm 3), χ G i ( u ) =
Revised: By definition of the DSS-WL aggregation procedure (Line 6 in Algorithm 3), χ G i ( u ) =

Original: χ H i ( v ) already implies {{ χ G i ( w ) : w ∈ N G i ( u ) }} = {{ χ H j ( w ) : w ∈ N H j ( v ) }} .
Revised: χ H i ( v ) already implies {{ χ G i ( w ) : w ∈ N G i ( u ) }} = {{ χ H j ( w ) : w ∈ N H j ( v ) }} .

Original: Namely, |{ w : w ∈ N G i ( u ) ∩ χ − 1 G i ( c ) }| = |{ w : w ∈ N H j ( v ) ∩ χ − 1 H j ( c ) }| holds for any c ∈ C .
Revised: Namely, |{ w : w ∈ N G i ( u ) ∩ χ − 1 G i ( c ) }| = |{ w : w ∈ N H j ( v ) ∩ χ − 1 H j ( c ) }| holds for any c ∈ C .

Original: We then turn to the first bullet.
Revised: We then turn to the first bullet.

Original: If χ G ( u ) = χ H ( v ) , then {{ χ G i ( u ) : i ∈ [ m G ] }} = {{ χ H j ( v ) : j ∈ [ m H ] }} (Line 7 in Algorithm 3).
Revised: If χ G ( u ) = χ H ( v ) , then {{ χ G i ( u ) : i ∈ [ m G ] }} = {{ χ H j ( v ) : j ∈ [ m H ] }} (Line 7 in Algorithm 3).

Original: Then there exists a pair of indices i ∈
Revised: Then there exists a pair of indices i ∈

Original: [ m G ] and j ∈ [ m H ] such that χ G i ( u ) =
Revised: [ m G ] and j ∈ [ m H ] such that χ G i ( u ) =

Original: χ H j ( v ) .
Revised: χ H j ( v ) .

Original: By definition of the DSS-WL aggregation, it implies {{ χ G ( w ) : w ∈
Revised: By definition of the DSS-WL aggregation, it implies {{ χ G ( w ) : w ∈

Original: N G ( u ) }} = {{ χ H ( w ) : w ∈ N H ( v ) }} and concludes the proof.
Revised: N G ( u ) }} = {{ χ H ( w ) : w ∈ N H ( v ) }} and concludes the proof.

Original: Proposition C.4.
Revised: Proposition C.4.

Original: Let χ G and χ H be two mappings returned by SPD-WL (Algorithm 4 with d G = dis G ) for graphs G and H , respectively.
Revised: Let χ G and χ H be two mappings returned by SPD-WL (Algorithm 4 with d G = dis G ) for graphs G and H , respectively.

Original: Then χ G and χ H jointly satisfy the WL-condition.
Revised: Then χ G and χ H jointly satisfy the WL-condition.

Original: Proof.
Revised: Proof.

Original: If χ G ( u ) = χ H ( v ) for some nodes u, v , then by the update rule (Line 4 in Algorithm 4) {{
Revised: If χ G ( u ) = χ H ( v ) for some nodes u, v , then by the update rule (Line 4 in Algorithm 4) {

Original: [Equation]
Revised: [Equation]

Original: dis
Revised: w

Original: [Equation]
Revised: [Equation]

Original: u,
Revised: w

Original: [Equation]

Original: , χ G

Original: [Equation]
Revised: [Equation]

Original: w
Revised: w

Original: [Equation]
Revised: [Equation]

Original: w ∈
Revised: V

Original: [Equation]
Revised: [Equation]

Original: } = {{ (dis G ( v, w ) , χ G ( w )) : w ∈ V}} . Since w ∈ N G ( u ) if and only if dis G ( u, w ) = 1 , we have {{ χ G ( w ) : w ∈ N G ( u ) }} = {{ χ G ( w ) : w ∈ N G ( v ) }} .
Revised: Since w ∈ N G ( u ) if and only if dis G ( u, w ) = 1 , we have {{ χ G ( w ) : w ∈ N G ( u ) }} = {{ χ G ( w ) : w ∈ N G ( v ) }} .

Original: Therefore, for any c ∈ C , |{ w : w ∈ N G ( u ) ∩ χ − 1 G ( c ) }| = |{ w : w ∈ N G ( v ) ∩ χ − 1 G ( c ) }| .
Revised: Therefore, for any c ∈ C , |{ w : w ∈ N G ( u ) ∩ χ − 1 G ( c ) }| = |{ w : w ∈ N G ( v ) ∩ χ − 1 G ( c ) }| .

Original: Proposition C.5.
Revised: Proposition C.5.

Original: Let χ G and χ H be two vertex color mappings returned by the k -FWL algorithm ( k ≥ 2 ).
Revised: Let χ G and χ H be two vertex color mappings returned by the k -FWL algorithm ( k ≥ 2 ).

Original: Then χ G and χ H jointly satisfy the WL-condition.
Revised: Then χ G and χ H jointly satisfy the WL-condition.

Original: Proof.
Revised: Proof.

Original: Let χ G ( u )
Revised: Let χ G ( u )

Original: =
Revised: =

Original: χ H ( v ) for some u ∈ V G and v ∈ V H .
Revised: χ H ( v ) for some u ∈ V G and v ∈ V H .

Original: By the update formula (Line 4 in
Revised: By the update formula (Line 4 in

Original: Algorithm 2), {{ χ G ( u, · · · , u, w ) : w ∈ V G }} = {{ χ H ( v, · · · , v, w ) : w ∈ V H }} .
Revised: Algorithm 2), {{ χ G ( u, · · · , u, w ) : w ∈ V G }} = {{ χ H ( v, · · · , v, w ) : w ∈ V H }} .

Original: Note that for any nodes w 1 ∈ V G , w 2 ∈ V H and any x 1 ∈ N G ( w 1 ) , x 2 / ∈ N H ( w 2 ) , one has χ G ( w 1 , · · · , w 1 , x 1 ) ̸
Revised: Note that for any nodes w 1 ∈ V G , w 2 ∈ V H and any x 1 ∈ N G ( w 1 ) , x 2 / ∈ N H ( w 2 ) , one has χ G ( w 1 , · · · , w 1 , x 1 ) ̸

Original: = χ H ( w 2 , · · · , w 2 , x 2 ) .
Revised: = χ H ( w 2 , · · · , w 2 , x 2 ) .

Original: This is obtained by the definition of the initialization mapping χ 0 G and the fact that χ G refines χ 0 G .
Revised: This is obtained by the definition of the initialization mapping χ 0 G and the fact that χ G refines χ 0 G .

Original: Consequently, {{ χ G ( u, · · · , u, w ) : w ∈ N G ( u ) }} = {{ χ G ( v, · · · , v, w ) : w ∈ N H ( v ) }} .
Revised: Consequently, {{ χ G ( u, · · · , u, w ) : w ∈ N G ( u ) }} = {{ χ G ( v, · · · , v, w ) : w ∈ N H ( v ) }} .

Original: Next, we can use the fact that if χ G ( u, · · · , u, w 1 ) =
Revised: Next, we can use the fact that if χ G ( u, · · · , u, w 1 ) =

Original: χ G ( v, · · · , v, w 2 ) for some w 1 , w 2 ∈ V , then χ G ( w 1 ) =
Revised: χ G ( v, · · · , v, w 2 ) for some w 1 , w 2 ∈ V , then χ G ( w 1 ) =

Original: χ G ( w 2 ) (see Lemma C.6).
Revised: χ G ( w 2 ) (see Lemma C.6).

Original: Therefore, {{ χ G ( w ) : w ∈ N G ( u ) }} = {{ χ G ( w ) : w ∈ N H ( v ) }} , which concludes the proof.
Revised: Therefore, {{ χ G ( w ) : w ∈ N G ( u ) }} = {{ χ G ( w ) : w ∈ N H ( v ) }} , which concludes the proof.

Original: To complete the proof of Proposition C.5, it remains to prove the following lemma:
Revised: To complete the proof of Proposition C.5, it remains to prove the following lemma:

Original: Lemma C.6.
Revised: Lemma C.6.

Original: Let χ G and χ H be color mappings for graphs G and H in the k -FWL algorithm ( k ≥ 2 ).
Revised: Let χ G and χ H be color mappings for graphs G and H in the k -FWL algorithm ( k ≥ 2 ).

Original: Denote
Revised: Denote

Original: [Equation]
Revised: [Equation]

Original: Then for any i ∈ [ k − 1] and any nodes u, w ∈ V G , v, x ∈ V H , if χ G (cat k − i,i ( u, w ))
Revised: Then for any i ∈ [ k − 1] and any nodes u, w ∈ V G , v, x ∈ V H , if χ G (cat k − i,i ( u, w ))

Original: =
Revised: =

Original: χ H (cat k − i,i ( v, x )) , then χ G (cat k − i − 1 ,i +1 ( u, w ))
Revised: χ H (cat k − i,i ( v, x )) , then χ G (cat k − i − 1 ,i +1 ( u, w ))

Original: =
Revised: =

Original: χ H (cat k − i − 1 ,i +1 ( v, x )) .
Revised: χ H (cat k − i − 1 ,i +1 ( v, x )) .

Original: Consequently, χ G ( w ) =
Revised: Consequently, χ G ( w ) =

Original: χ H ( x ) .
Revised: χ H ( x ) .

Original: Proof.
Revised: Proof.

Original: By the update formula (Line 4 in Algorithm 2), χ G (cat k − i,i ( u, w ))
Revised: By the update formula (Line 4 in Algorithm 2), χ G (cat k − i,i ( u, w ))

Original: =
Revised: =

Original: χ H (cat k − i,i ( v, x )) implies that {{ χ G (cat k − i − 1 , 1 ,i ( u, y, w )) :
Revised: χ H (cat k − i,i ( v, x )) implies that {{ χ G (cat k − i − 1 , 1 ,i ( u, y, w )) :

Original: y ∈ V G }} = {{ χ H (cat k − i − 1 , 1 ,i ( v, y, x )) :
Revised: y ∈ V G }} = {{ χ H (cat k − i − 1 , 1 ,i ( v, y, x )) :

Original: y ∈ V H }} .
Revised: y ∈ V H }} .

Original: Note that for any j ∈ [ k − 1] and any z ∈ V kG , z ′ ∈ V kH with z j = z
Revised: Note that for any j ∈ [ k − 1] and any z ∈ V kG , z ′ ∈ V kH with z j = z

Original: j +1 but z ′
Revised: j +1 but z ′

Original: j ̸ =
Revised: j ̸ =

Original: z ′
Revised: z ′

Original: j +1 , one has χ G ( z ) ̸
Revised: j +1 , one has χ G ( z ) ̸

Original: = χ H ( z ′ ) .
Revised: = χ H ( z ′ ) .

Original: This is obtained by the definition of the initialization mapping χ 0 G and the fact that χ G refines χ 0 G .
Revised: This is obtained by the definition of the initialization mapping χ 0 G and the fact that χ G refines χ 0 G .

Original: Therefore, we have χ G (cat k − i − 1 ,i +1 ( u, w ))
Revised: Therefore, we have χ G (cat k − i − 1 ,i +1 ( u, w ))

Original: =
Revised: =

Original: χ H (cat k − i − 1 ,i +1 ( v, x )) , as desired.
Revised: χ H (cat k − i − 1 ,i +1 ( v, x )) , as desired.

Original: Equipped with the concept of WL-condition, we now present several key results.
Revised: Equipped with the concept of WL-condition, we now present several key results.

Original: In the following, let χ G : V G → C and χ H : V H
Revised: In the following, let χ G : V G → C and χ H : V H

Original: → C be two color mappings jointly satisfying the WL-condition.
Revised: → C be two color mappings jointly satisfying the WL-condition.

Original: Lemma C.7.
Revised: Lemma C.7.

Original: Let ( v 0 , · · · , v d ) be any path (not necessarily simple) of length d in graph G .
Revised: Let ( v 0 , · · · , v d ) be any path (not necessarily simple) of length d in graph G .

Original: Then for any node u 0 ∈ χ − 1 H ( χ G ( v 0 )) in graph H , there exists a path ( u 0 , · · · , u d ) of the same length d
Revised: Then for any node u 0 ∈ χ − 1 H ( χ G ( v 0 )) in graph H , there exists a path ( u 0 , · · · , u d ) of the same length d

Original: starting at u 0 , such that χ H ( u i )
Revised: starting at u 0 , such that χ H ( u i )

Original: =
Revised: =

Original: χ G ( v i ) holds for all
Revised: χ G ( v i ) holds for all

Original: i ∈
Revised: i ∈

Original: [ d ] .
Revised: [ d ] .

Original: Proof.
Revised: Proof.

Original: The proof is based on induction over the path length d .
Revised: The proof is based on induction over the path length d .

Original: For the base case of d = 1 , if the conclusion does not hold, then there exists two vertices u ∈ V G , v ∈ V H with the same color (i.e. χ G ( u ) =
Revised: For the base case of d = 1 , if the conclusion does not hold, then there exists two vertices u ∈ V G , v ∈ V H with the same color (i.e. χ G ( u ) =

Original: χ H ( v ) ) and a color c = χ G ( v 1 ) such that N G ( u ) ∩ χ − 1 G ( c ) ̸ = ∅ but N H ( v ) ∩ χ − 1 H ( c ) = ∅ .
Revised: χ H ( v ) ) and a color c = χ G ( v 1 ) such that N G ( u ) ∩ χ − 1 G ( c ) ̸ = ∅ but N H ( v ) ∩ χ − 1 H ( c ) = ∅ .

Original: This obviously contradicts the WL-condition.
Revised: This obviously contradicts the WL-condition.

Original: For the induction step on the path length d , one can just split it by two parts ( v 0 , · · · , v d − 1 ) and ( v d − 1 , v d ) .
Revised: For the induction step on the path length d , one can just split it by two parts ( v 0 , · · · , v d − 1 ) and ( v d − 1 , v d ) .

Original: Separately using induction yields two paths ( u 0 , · · · , u d − 1 ) and ( u d − 1 , u d ) such that χ H ( u i ) =
Revised: Separately using induction yields two paths ( u 0 , · · · , u d − 1 ) and ( u d − 1 , u d ) such that χ H ( u i ) =

Original: χ G ( v i ) for all i ∈
Revised: χ G ( v i ) for all i ∈

Original: [ d ] .
Revised: [ d ] .

Original: By linking the two paths we have completed the proof.
Revised: By linking the two paths we have completed the proof.

Original: Finally, let us define the shortest path distance between node u and vertex set S as dis G ( u, S ) :
Revised: Finally, let us define the shortest path distance between node u and vertex set S as dis G ( u, S ) :

Original: = min v ∈S dis G ( u, v ) .
Revised: = min v ∈S dis G ( u, v ) .

Original: The above lemma directly yields the following corollary:
Revised: The above lemma directly yields the following corollary:

Original: Corollary C.8.
Revised: Corollary C.8.

Original: For any color c ∈ { χ G ( w ) : w ∈ V G } and any two vertices u ∈ V G , v ∈ V H with the same color (i.e. χ G ( u ) =
Revised: For any color c ∈ { χ G ( w ) : w ∈ V G } and any two vertices u ∈ V G , v ∈ V H with the same color (i.e. χ G ( u ) =

Original: [Equation]
Revised: [Equation]

Original: v ) ),

Original: [Equation]
Revised: [Equation]

Original: = dis H ( v, χ − 1 H ( c )) .
Revised: ( v, χ − 1 H ( c )) .

Original: C. C OUNTEREXAMPLES
Revised: C. C OUNTEREXAMPLES

Original: We provides the following two families of counterexamples, which most prior works cannot distinguish.
Revised: We provides the following two families of counterexamples, which most prior works cannot distinguish.

Original: Example C.9.
Revised: Example C.9.

Original: Let G 1 =
Revised: Let G 1 =

Original: ( V , E 1 ) and G 

Revised: ( V , E 1 ) and G

Original: =
Revised: =

Original: ( V , E 2 ) be a pair of graphs with n = 2 km + 1 nodes where m, k are two positive integers satisfying mk ≥ 3 .
Revised: ( V , E 2 ) be a pair of graphs with n = 2 km + 1 nodes where m, k are two positive integers satisfying mk ≥ 3 .

Original: Denote V =
Revised: Denote V =

Original: [ n ] and define the edge sets as follows:
Revised: [ n ] and define the edge sets as follows:

Original: [Equation]
Revised: [Equation]

Original: i mod 2 km ) + 1 } : i ∈ [2 km ] } ∪ {{ n, i } : i ∈ [2 km ] , i mod m = 0 } ,
Revised: mod 2 km ) + 1 } : i ∈ [2 km ] } ∪ {{ n, i } : i ∈ [2 km ] , i mod m = 0 } ,

Original: E 

Revised: E

Original: = {{ i, ( i mod km ) + 1 } : i ∈ [ km ] } ∪ {{ i + km, ( i mod km ) + km + 1 } : i ∈ [ km ] } ∪ {{ n, i } : i ∈
Revised: = {{ i, ( i mod km ) + 1 } : i ∈ [ km ] } ∪ {{ i + km, ( i mod km ) + km + 1 } : i ∈ [ km ] } ∪ {{ n, i } : i ∈

Original: [2 km ] , i mod m = 0 } .
Revised: [2 km ] , i mod m = 0 } .

Original: See Figure 2(a-c) for an illustration of three cases: (i) m
Revised: See Figure 2(a-c) for an illustration of three cases: (i) m

Original: = 2 , k = 2 ; (ii) m = 4 , k = 1 ; (iii) m = 1 , k
Revised: = 2 , k = 2 ; (ii) m = 4 , k = 1 ; (iii) m = 1 , k

Original: =
Revised: =

Original: It is easy to see that regardless of the chosen of m and k , G 1 always has no cut vertex but G 2 do always have a cut vertex with node number n .
Revised: It is easy to see that regardless of the chosen of m and k , G 1 always has no cut vertex but G 2 do always have a cut vertex with node number n .

Original: The case of k = 1 is more special, for which G 2 actually has three cut vertices with node number m , 2 m , and n , respectively, and it even has two cut edges { m, n } and { 2 m, n } (Figure 2(b)).
Revised: The case of k = 1 is more special, for which G 2 actually has three cut vertices with node number m , 2 m , and n , respectively, and it even has two cut edges { m, n } and { 2 m, n } (Figure 2(b)).

Original: Example C.10.
Revised: Example C.10.

Original: Let G 1 =
Revised: Let G 1 =

Original: ( V , E 1 ) and G 

Revised: ( V , E 1 ) and G

Original: =
Revised: =

Original: ( V , E 2 ) be a pair of graphs with n = 2 m nodes where m ≥ 3 is an arbitrary integer.
Revised: ( V , E 2 ) be a pair of graphs with n = 2 m nodes where m ≥ 3 is an arbitrary integer.

Original: Denote V =
Revised: Denote V =

Original: [ n ] and define the edge sets as follows:
Revised: [ n ] and define the edge sets as follows:

Revised: E

Revised: [Equation]

Revised: } : i

Revised: [Equation]

Revised: n

Original: [Equation]
Revised: [Equation]

Revised: m,

Revised: [Equation]

Revised: m }} ,

Revised: E

Revised: [Equation]

Revised: , ( i

Revised: [Equation]

Original: m
Revised: m

Revised: [Equation]

Revised: [Equation]

Revised: i

Revised: [Equation]

Revised: m ]

Original: [Equation]
Revised: [Equation]

Revised: m

Revised: [Equation]

Revised: m

Original:  See Figure 2(d) for an illustration of the case n = 8 .
Revised: [Equation] [Equation] m ] } ∪ {{ m, 2 m }} . See Figure 2(d) for an illustration of the case n = 8 .

Original: It is easy to see that G 1 does not have any cut vertex or cut edge, but G 2 do have two cut vertices with node number m and 2 m , and has a cut edge { m, 2 m } .
Revised: It is easy to see that G 1 does not have any cut vertex or cut edge, but G 2 do have two cut vertices with node number m and 2 m , and has a cut edge { m, 2 m } .

Original: Theorem C.11.
Revised: Theorem C.11.

Original: Let H
Revised: Let H

Original: =
Revised: =

Original: { H 1 , · · · , H k } , H i =
Revised: { H 1 , · · · , H k } , H i =

Original: ( V i , E i ) be any set of connected graphs and denote n V = max i ∈ [ k ] |V i | .
Revised: ( V i , E i ) be any set of connected graphs and denote n V = max i ∈ [ k ] |V i | .

Original: Then SC-WL (Appendix B.3) using the substructure set H
Revised: Then SC-WL (Appendix B.3) using the substructure set H

Original: can neither distinguish whether a given graph has cut vertices nor distinguish whether it has cut edges.
Revised: can neither distinguish whether a given graph has cut vertices nor distinguish whether it has cut edges.

Original: Moreover, there exist counterexample graphs whose size (both in terms of vertices and edges) is O ( n V ) .
Revised: Moreover, there exist counterexample graphs whose size (both in terms of vertices and edges) is O ( n V ) .

Original: Proof.
Revised: Proof.

Original: We would like to prove that SC-WL cannot distinguish both Examples C.9 and C.10 when n V < m ( m is defined in these examples).
Revised: We would like to prove that SC-WL cannot distinguish both Examples C.9 and C.10 when n V < m ( m is defined in these examples).

Original: First note that for both examples, any cycle in both Gand G 2 has a length of at least m .
Revised: First note that for both examples, any cycle in both Gand G 2 has a length of at least m .

Original: Since the number of nodes in H i is O ( n V ) , if H i contains cycles, it will not occur in both G 1 and G 2 , thus taking no effect in distinguishing the two graphs.
Revised: Since the number of nodes in H i is O ( n V ) , if H i contains cycles, it will not occur in both G 1 and G 2 , thus taking no effect in distinguishing the two graphs.

Original: As a result, we can simply assume all graphs in H are trees (connected graphs with no cycles).
Revised: As a result, we can simply assume all graphs in H are trees (connected graphs with no cycles).

Original: Below, we provide a complete proof for Example C.9, which already yields the conclusion that SC-WL can neither distinguish cut vertices nor cut edges.
Revised: Below, we provide a complete proof for Example C.9, which already yields the conclusion that SC-WL can neither distinguish cut vertices nor cut edges.

Original: We omit the proof for Example C.10 since the proof technique is similar.
Revised: We omit the proof for Example C.10 since the proof technique is similar.

Original: Proof for Example C.9 .
Revised: Proof for Example C.9 .

Original: Let H i be a tree with less than m vertices where m is defined in Example C.9.
Revised: Let H i be a tree with less than m vertices where m is defined in Example C.9.

Original: By symmetry of the two graphs G 1 and G 2 , it suffices to prove the following two types of equations: x V G 1 ( n ) =
Revised: By symmetry of the two graphs G 1 and G 2 , it suffices to prove the following two types of equations: x V G 1 ( n ) =

Original: x V G 2 ( n ) and x V G 1 ( i ) =
Revised: x V G 2 ( n ) and x V G 1 ( i ) =

Original: x V G 2 ( i ) for all m < i ≤ 2 m , where x V is defined in (8).
Revised: x V G 2 ( i ) for all m < i ≤ 2 m , where x V is defined in (8).

Original: We first aim to prove that x V G 1 ( v ) =
Revised: We first aim to prove that x V G 1 ( v ) =

Original: x V G 2 ( v ) for v ∈ { m + 1 , · · · , 2 m } .
Revised: x V G 2 ( v ) for v ∈ { m + 1 , · · · , 2 m } .

Original: Consider an induced subgraph G 1 [ S ] which is isomorphic to H i and contains node v .
Revised: Consider an induced subgraph G 1 [ S ] which is isomorphic to H i and contains node v .

Original: Define the set T :
Revised: Define the set T :

Original: = { jm : j ∈ [ k ] }∩S .
Revised: = { jm : j ∈ [ k ] }∩S .

Original: For ease of presentation, we define an operation cir( x, a, b ) that outputs an integer y in the range of ( a, b ] such that y has the same remainder as x (mod b − a ).
Revised: For ease of presentation, we define an operation cir( x, a, b ) that outputs an integer y in the range of ( a, b ] such that y has the same remainder as x (mod b − a ).

Original: Formally, cir( x, a, b ) =
Revised: Formally, cir( x, a, b ) =

Original: y if a < y ≤ b and x ≡ y (mod b − a ) .
Revised: y if a < y ≤ b and x ≡ y (mod b − a ) .

Original: • If n / ∈ S , then it is easy to see that G 1 [ S ] is a chain, i.e., no vertices have a degree larger than 2.
Revised: • If n / ∈ S , then it is easy to see that G 1 [ S ] is a chain, i.e., no vertices have a degree larger than 2.

Original: We define the following mapping g S : S →
Revised: We define the following mapping g S : S →

Original: [ n ] , such that
Revised: [ n ] , such that

Revised: [Equation]

Revised: u

Revised: [Equation]

Revised: cir

Original: [Equation]
Revised: [Equation]

Revised: u

Original:  In this way, the chain G 1 [ S ] is mapped to a chain of G 2 that contains v .
Revised: [Equation] [Equation] if k ≥ 2 . In this way, the chain G 1 [ S ] is mapped to a chain of G 2 that contains v .

Original: Concretely, denote g S ( S )
Revised: Concretely, denote g S ( S )

Original: = { g S ( u ) : u ∈ S} , then G 2 [ g S ( S )] ≃ G 1 [ S ] ≃ H i , and obviously the orbit of v in
Revised: = { g S ( u ) : u ∈ S} , then G 2 [ g S ( S )] ≃ G 1 [ S ] ≃ H i , and obviously the orbit of v in

Original: G 2 [ g S ( S )] matches the orbit of v in G 1 [ S ] .
Revised: G 2 [ g S ( S )] matches the orbit of v in G 1 [ S ] .

Original: See Figure 3(a,b) for an illustration of this case.
Revised: See Figure 3(a,b) for an illustration of this case.

Original:  If n ∈ S , then it is easy to see that the set T ̸ = ∅ .
Revised: • If n ∈ S , then it is easy to see that the set T ̸ = ∅ .

Original: We will similarly construct a mapping g S : S → [ n ] that maps S to g S ( S ) satisfying g S ( v ) = v , which is defined as follows
Revised: We will similarly construct a mapping g S : S → [ n ] that maps S to g S ( S ) satisfying g S ( v ) = v , which is defined as follows.

Original: For

Original: each

Original: u ∈ S

Original: { n

Original: } , we

Original: find

Original:  a unique vertex w u in T such that dis G 1 [ S ] 
Revised: For each u ∈ S\{ n } , we find a unique vertex w u in T such that dis G 1 [ S ] ( u, w u ) is the minimum.

Original: u, w u is the minimum. Note that the node w u is well-defined since T ̸ = ∅ and any path in G 1 [ S ] from u to a node in T goes through w u .
Revised: Note that the node w u is well-defined since T ̸ = ∅ and any path in G 1 [ S ] from u to a node in T goes through w u .

Original: Define
Revised: Define

Original: [Equation]
Revised: [Equation]

Original: We also define g S ( n ) = n .
Revised: We also define g S ( n ) = n .

Original: Such a definition guarantees that for any x 1 , x 2 ∈ S , { x 1 , x 2 } ∈
Revised: Such a definition guarantees that for any x 1 , x 2 ∈ S , { x 1 , x 2 } ∈

Original: E G 1 ⇐⇒ { g S ( x 1 ) , g S ( x 2 ) }
Revised: E G 1 ⇐⇒ { g S ( x 1 ) , g S ( x 2 ) }

Original: ∈ E G 2 .
Revised: ∈ E G 2 .

Original: Therefore, G 2 [ g S ( S )] ≃ G 1 [ S ] ≃ H i .
Revised: Therefore, G 2 [ g S ( S )] ≃ G 1 [ S ] ≃ H i .

Original: Moreover, observe that g S ( u ) ≡ u (mod m ) always holds, and thus it is easy to see that the orbit of v in G 2 [ g S ( S )] matches the orbit of v in G1 [ S ] Figure 3(c,d) 𝑣𝑣 2𝑚𝑚− 𝑚𝑚+ 𝑚𝑚+ 2𝑚𝑚 𝑚𝑚−1 𝑚𝑚+1 𝑚𝑚+     … … 𝑚𝑚−1 𝑚𝑚 𝑚𝑚 … … 2𝑚𝑚−1 2𝑚𝑚
Revised: Moreover, observe that g S ( u ) ≡ u (mod m ) always holds, and thus it is easy to see that the orbit of v in G 2 [ g S ( S )] matches the orbit of v in G 𝑣𝑣 2𝑚𝑚− 𝑚𝑚+ 𝑚𝑚+ 2𝑚𝑚 𝑚𝑚−1 𝑚𝑚+1 𝑚𝑚+     … … 𝑚𝑚−1 𝑚𝑚 𝑚𝑚 … … 2𝑚𝑚−1 2𝑚𝑚

Original: 𝑛𝑛 𝑛𝑛 𝑣𝑣 𝑣𝑣 𝑣𝑣 1 2 2𝑚𝑚−1 2𝑚𝑚 2𝑚𝑚−1 2𝑚𝑚 2𝑚𝑚+ 1𝑚𝑚− 𝑚𝑚 𝑚𝑚+ 𝑚𝑚+ 𝑚𝑚+ … 𝑚𝑚−1 𝑚𝑚 𝑚𝑚+ … … 𝑛𝑛 2𝑚𝑚+ 3𝑚𝑚−1 3𝑚𝑚 3𝑚𝑚+ … 4𝑚𝑚−14𝑚𝑚 3𝑚𝑚− 3𝑚𝑚 3𝑚𝑚+ 4𝑚𝑚−1 4𝑚𝑚 𝑛𝑛 2𝑚𝑚−

Revised: 𝑛𝑛 𝑛𝑛 𝑣𝑣 𝑣𝑣 𝑣𝑣 1 2 2𝑚𝑚−1 2𝑚𝑚 2𝑚𝑚−1 2𝑚𝑚 2𝑚𝑚+ 1𝑚𝑚− 𝑚𝑚 𝑚𝑚+ 𝑚𝑚+ 𝑚𝑚+ … 𝑚𝑚−1 𝑚𝑚 𝑚𝑚+ … … 𝑛𝑛 2𝑚𝑚+ 3𝑚𝑚−1 3𝑚𝑚 3𝑚𝑚+ … 4𝑚𝑚−14𝑚𝑚 3𝑚𝑚− 3𝑚𝑚 3𝑚𝑚+ 4𝑚𝑚−1 4𝑚𝑚 𝑛𝑛 2𝑚𝑚−

Original: 𝑣𝑣 𝑣𝑣 𝑛𝑛 1 𝑚𝑚−1𝑚𝑚 𝑚𝑚+ 2𝑚𝑚 𝑚𝑚+ … 𝑚𝑚−1 𝑚𝑚 𝑚𝑚+ 𝑚𝑚+ 2𝑚𝑚−1 2𝑚𝑚
Revised: 𝑣𝑣 𝑣𝑣 𝑛𝑛 1 𝑚𝑚−1𝑚𝑚 𝑚𝑚+ 2𝑚𝑚 𝑚𝑚+ … 𝑚𝑚−1 𝑚𝑚 𝑚𝑚+ 𝑚𝑚+ 2𝑚𝑚−1 2𝑚𝑚

Original: 𝑛𝑛  … … … 𝑣𝑣 𝑣𝑣 1𝑚𝑚−1 𝑚𝑚 𝑚𝑚+ 2𝑚𝑚−1 2𝑚𝑚
Revised: 𝑛𝑛  … … … 𝑣𝑣 𝑣𝑣 1𝑚𝑚−1 𝑚𝑚 𝑚𝑚+ 2𝑚𝑚−1 2𝑚𝑚

Original: 𝑛𝑛 2𝑚𝑚+ 3𝑚𝑚−1 3𝑚𝑚 3𝑚𝑚+ 4𝑚𝑚−1 4𝑚𝑚 𝑚𝑚− 𝑚𝑚 𝑚𝑚+ 𝑚𝑚+ 2𝑚𝑚−1 2𝑚𝑚 2𝑚𝑚+ 4𝑚𝑚−1 4𝑚𝑚 𝑛𝑛 𝑚𝑚+ … … … …
Revised: 𝑛𝑛 2𝑚𝑚+ 3𝑚𝑚−1 3𝑚𝑚 3𝑚𝑚+ 4𝑚𝑚−1 4𝑚𝑚 𝑚𝑚− 𝑚𝑚 𝑚𝑚+ 𝑚𝑚+ 2𝑚𝑚−1 2𝑚𝑚 2𝑚𝑚+ 4𝑚𝑚−1 4𝑚𝑚 𝑛𝑛 𝑚𝑚+ … … … …

Original: 3𝑚𝑚− 3𝑚𝑚 3𝑚𝑚+
Revised: 3𝑚𝑚− 3𝑚𝑚 3𝑚𝑚+

Original: [Figure]
Revised: [Figure]

Original: Finally, note that for any two different sets S 1 and S 2 such that G 1 [ S 1 ] ≃ G 1 [ S 2 ] ≃ H i , we have g S 1 ( S 1 ) ̸
Revised: Finally, note that for any two different sets S 1 and S 2 such that G 1 [ S 1 ] ≃ G 1 [ S 2 ] ≃ H i , we have g S 1 ( S 1 ) ̸

Original: = g S 2 ( S 2 ) , which guarantees that the mapping g : {S ⊂ [ n ] : G 1 [ S ] ≃ H i , v ∈ S} → {S ⊂ [ n ] : G 2 [ S ] ≃ H i , v ∈ S} defined to be g ( S ) =
Revised: = g S 2 ( S 2 ) , which guarantees that the mapping g : {S ⊂ [ n ] : G 1 [ S ] ≃ H i , v ∈ S} → {S ⊂ [ n ] : G 2 [ S ] ≃ H i , v ∈ S} defined to be g ( S ) =

Original: g S ( S ) is injective.
Revised: g S ( S ) is injective.

Original: One can further check that the mapping g is also surjective, and thus it is bijective.
Revised: One can further check that the mapping g is also surjective, and thus it is bijective.

Original: This means x V G 1 ( v ) =
Revised: This means x V G 1 ( v ) =

Original: x V G 2 ( v ) for v ∈ { m, · · · , 2 m − 1 } .
Revised: x V G 2 ( v ) for v ∈ { m, · · · , 2 m − 1 } .

Original: The proof for x V G 1 ( n ) =
Revised: The proof for x V G 1 ( n ) =

Original: x V G 2 ( n ) is almost the same, so we omit it here.
Revised: x V G 2 ( n ) is almost the same, so we omit it here.

Original: Noting that under classic 1-WL, the colors χ G 1 ( v ) =
Revised: Noting that under classic 1-WL, the colors χ G 1 ( v ) =

Original: χ G 2 ( v ) are also the same.
Revised: χ G 2 ( v ) are also the same.

Original: Therefore, adding the features x V ( v ) does not help distinguish the two graphs.
Revised: Therefore, adding the features x V ( v ) does not help distinguish the two graphs.

Original: We have finished the proof for
Revised: We have finished the proof for

Original: Example C.9.
Revised: Example C.9.

Original: Using a similar cycle analysis as the above proof, we have the following negative result for Simplicial
Revised: Using a similar cycle analysis as the above proof, we have the following negative result for Simplicial

Original: WL (Bodnar et al., 2021b) and Cellular WL (Bodnar et al., 2021a):
Revised: WL (Bodnar et al., 2021b) and Cellular WL (Bodnar et al., 2021a):

Original: Proposition C.12.
Revised: Proposition C.12.

Original: Consider the SWL algorithm
Revised: Consider the SWL algorithm

Original: (Bodnar et al., 2021b), or more generally, the CWL algorithms with either k -CL, k -IC, or k -C as lifting maps ( k ≥ 3 is an integer)
Revised: (Bodnar et al., 2021b), or more generally, the CWL algorithms with either k -CL, k -IC, or k -C as lifting maps ( k ≥ 3 is an integer)

Original: (Bodnar et al., 2021a,
Revised: (Bodnar et al., 2021a,

Original: Definition 14).
Revised: Definition 14).

Original: These algorithms can neither distinguish whether a given graph has cut vertices nor distinguish whether it has cut edges.
Revised: These algorithms can neither distinguish whether a given graph has cut vertices nor distinguish whether it has cut edges.

Original: Proof.
Revised: Proof.

Original: Observe that the counterexample graphs in both Examples C.9 and C.10 do not have cliques.
Revised: Observe that the counterexample graphs in both Examples C.9 and C.10 do not have cliques.

Original: Therefore, SWL (or CWL with k -CL) reduces to the classic 1-WL and thus fails to distinguish them.
Revised: Therefore, SWL (or CWL with k -CL) reduces to the classic 1-WL and thus fails to distinguish them.

Original: Since the lengths of any cycles in these counterexample graphs are at least m ( m is defined in
Revised: Since the lengths of any cycles in these counterexample graphs are at least m ( m is defined in

Original: Examples C.9 and C.10), we have that CWL with k -IC or k -C also reduces to 1-WL when m > k .
Revised: Examples C.9 and C.10), we have that CWL with k -IC or k -C also reduces to 1-WL when m > k .

Original: Therefore, there exists graphs whose size is O ( k ) such that CWL can neither distinguish cut vertices nor cut edges.
Revised: Therefore, there exists graphs whose size is O ( k ) such that CWL can neither distinguish cut vertices nor cut edges.

Original: Finally, we point out that even if k is not a constant (i.e., can scale to the graph size), CWL with k -IC still fails to distinguish whether a given graph has cut vertices.
Revised: Finally, we point out that even if k is not a constant (i.e., can scale to the graph size), CWL with k -IC still fails to distinguish whether a given graph has cut vertices.

Original: This is because for Example C.9 with k ≥ 2 (e.g. Figure 2(b,c)), CWL with IC still outputs the same graph representation for both Gand G 2 .
Revised: This is because for Example C.9 with k ≥ 2 (e.g. Figure 2(b,c)), CWL with IC still outputs the same graph representation for both Gand G 2 .

Original: This happens because all the 2-dimensional cells in these examples are cycles of an equal length of m + 2 and one can easily check that they have the same CWL color.
Revised: This happens because all the 2-dimensional cells in these examples are cycles of an equal length of m + 2 and one can easily check that they have the same CWL color.

Original: We finally turn to the case of subgraph-based WL variants.
Revised: We finally turn to the case of subgraph-based WL variants.

Original: Proposition C.13.
Revised: Proposition C.13.

Original: The Overlap Subgraph WL (Wijesinghe & Wang, 2022) using any subgraph mapping ω can neither distinguish whether a given graph has cut vertices nor distinguish whether it has cut edges.
Revised: The Overlap Subgraph WL (Wijesinghe & Wang, 2022) using any subgraph mapping ω can neither distinguish whether a given graph has cut vertices nor distinguish whether it has cut edges.

Original: Proof.
Revised: Proof.

Original: An important limitation of OS-WL is that if a graph does not contain triangles, then any overlap subgraph S uv between two adjacent nodes u, v will only have one edge { u, v } .
Revised: An important limitation of OS-WL is that if a graph does not contain triangles, then any overlap subgraph S uv between two adjacent nodes u, v will only have one edge { u, v } .

Original: Consequently, the subgraph mapping ω does not take effect can OS-WL reduces to the classic 1-WL.
Revised: Consequently, the subgraph mapping ω does not take effect can OS-WL reduces to the classic 1-WL.

Original: Therefore,
Revised: Therefore,

Original: Example C.9 with m > 1 and Example C.10 with m > 3 still apply here since the graphs G 1 and Gdo not contain triangles (see Figure 2(a,b,d)).
Revised: Example C.9 with m > 1 and Example C.10 with m > 3 still apply here since the graphs G 1 and Gdo not contain triangles (see Figure 2(a,b,d)).

Original: Moreover, Example C.9 with m = 1 (see Figure 2(c)) is also a counterexample as discussed in Wijesinghe & Wang (2022, Figure 2(a)).
Revised: Moreover, Example C.9 with m = 1 (see Figure 2(c)) is also a counterexample as discussed in Wijesinghe & Wang (2022, Figure 2(a)).

Original: Proposition C.14.
Revised: Proposition C.14.

Original: The DSS-WL with ego network policy without marking cannot distinguish the graphs in Example C.9 with m = 1 (Figure 2(c)).
Revised: The DSS-WL with ego network policy without marking cannot distinguish the graphs in Example C.9 with m = 1 (Figure 2(c)).

Original: Proof.
Revised: Proof.

Original: First note that for any two vertices u, v in either G 1 or G 2 defined in Example C.9, their shortest path distance does not exceed 2.
Revised: First note that for any two vertices u, v in either G 1 or G 2 defined in Example C.9, their shortest path distance does not exceed 2.

Original: Thus we only need to consider the ego network policy π EGO(1) and π EGO(2) 
Revised: Thus we only need to consider the ego network policy π EGO(1) and π EGO(2) .

Original: • For π EGO(2) , the ego graphs of all nodes are simply the original graph and thus all graphs in the bag B π and equal.
Revised: • For π EGO(2) , the ego graphs of all nodes are simply the original graph and thus all graphs in the bag B π and equal.

Original: Thus DSS-WL reduces to the classic 1-WL and cannot distinguish G 1 and G 2 .
Revised: Thus DSS-WL reduces to the classic 1-WL and cannot distinguish G 1 and G 2 .

Original: • For π EGO(1) , the ego graph of each node v ̸ = n is a graph with 5 edges, having a shape of two triangles sharing one edge.
Revised: • For π EGO(1) , the ego graph of each node v ̸ = n is a graph with 5 edges, having a shape of two triangles sharing one edge.

Original: These ego graphs are clearly isomorphic.
Revised: These ego graphs are clearly isomorphic.

Original: The ego graph of the special node n is the original graph containing all edges.
Revised: The ego graph of the special node n is the original graph containing all edges.

Original: It is easy to see that the vertex partition of DSS-WL becomes stable only after one iteration, and the color mapping of Gand G 2 is the same.
Revised: It is easy to see that the vertex partition of DSS-WL becomes stable only after one iteration, and the color mapping of Gand G 2 is the same.

Original: Therefore, DSS-WL cannot distinguish G 1 and G 2 .
Revised: Therefore, DSS-WL cannot distinguish G 1 and G 2 .

Original: We thus conclude the proof.
Revised: We thus conclude the proof.

Original: Proposition C.15.
Revised: Proposition C.15.

Original: The GNN-AK architecture proposed in Zhao et al.
Revised: The GNN-AK architecture proposed in Zhao et al.

Original: (2022) cannot distinguish whether a given graph has cut vertices.
Revised: (2022) cannot distinguish whether a given graph has cut vertices.

Original: Proof.
Revised: Proof.

Original: The GNN-AK architecture is quite similar to DSS-WL using the ego network policy but is weaker.
Revised: The GNN-AK architecture is quite similar to DSS-WL using the ego network policy but is weaker.

Original: There is also a subtle difference: GNN-AK adds the so-called centroid encoding.
Revised: There is also a subtle difference: GNN-AK adds the so-called centroid encoding.

Original: However, unlike node marking that is performed before the WL procedure, centroid encoding is performed after the WL procedure.
Revised: However, unlike node marking that is performed before the WL procedure, centroid encoding is performed after the WL procedure.

Original: The subtle difference causes GNN-AK to be unable to distinguish between the two graphs G 1 and G 2 .
Revised: The subtle difference causes GNN-AK to be unable to distinguish between the two graphs G 1 and G 2 .

Original: We finally consider the DS-WL algorithm proposed in Cotta et al.
Revised: We finally consider the DS-WL algorithm proposed in Cotta et al.

Original: (2021); Bevilacqua et al.
Revised: (2021); Bevilacqua et al.

Original: As discussed in Appendix B.4, the original DS-WL formulation only outputs a graph representation rather than node colors.
Revised: As discussed in Appendix B.4, the original DS-WL formulation only outputs a graph representation rather than node colors.

Original: There are two simple ways to define nodes colors for DS-WL:
Revised: There are two simple ways to define nodes colors for DS-WL:

Original: • If the graph generation policy π is node-based, then each subgraph in B πG = {{ G i }} |V| i =1 is uniquely associated to a specific node v ∈ V .
Revised: • If the graph generation policy π is node-based, then each subgraph in B πG = {{ G i }} |V| i =1 is uniquely associated to a specific node v ∈ V .

Original: We can thus use the graph representation of each subgraph G i as the color of each node.
Revised: We can thus use the graph representation of each subgraph G i as the color of each node.

Original: This strategy has appeared in prior works, e.g. Zhao et al.
Revised: This strategy has appeared in prior works, e.g. Zhao et al.

Original: • For a general graph generation policy π , there no longer exists an explicit bijective mapping between nodes and subgraphs.
Revised: • For a general graph generation policy π , there no longer exists an explicit bijective mapping between nodes and subgraphs.

Original: In this case, another possible way is to define χ G ( v ) :
Revised: In this case, another possible way is to define χ G ( v ) :

Original: = {{ χ G i ( v ) : G i ∈ B πG }} , similar to DSS-WL.
Revised: = {{ χ G i ( v ) : G i ∈ B πG }} , similar to DSS-WL.

Original: This approach is recently introduced by Qian et al.
Revised: This approach is recently introduced by Qian et al.

Original: However, such a strategy loses the memory advantage of DS-WL (i
Revised: However, such a strategy loses the memory advantage of DS-WL (i

Original: e., needing Θ( |V||B πG | ) memory complexity rather than Θ( |V| + |B πG | ) )
Revised: e., needing Θ( |V||B πG | ) memory complexity rather than Θ( |V| + |B πG | ) )

Original: , and is less expressive than DSSWL.
Revised: , and is less expressive than DSSWL.

Original: We thus do not study this variant in the present work.
Revised: We thus do not study this variant in the present work.

Original: Proposition C.16.
Revised: Proposition C.16.

Original: The DS-WL algorithm with node marking/deletion policy cannot distinguish cut vertices when each node’s color is defined as its associated subgraph representation.
Revised: The DS-WL algorithm with node marking/deletion policy cannot distinguish cut vertices when each node’s color is defined as its associated subgraph representation.

Original: Proof.
Revised: Proof.

Original: One can similarly check that for Example C.9 with m = 1 (see Figure 2(c)), the color of node n will be the same for both graphs G 1 and G 2 .
Revised: One can similarly check that for Example C.9 with m = 1 (see Figure 2(c)), the color of node n will be the same for both graphs G 1 and G 2 .

Original: Therefore, the algorithm cannot distinguish cut vertices.
Revised: Therefore, DS-WL cannot identify cut vertices.

Revised: Finally, using a similar proof technique, the NGNN architecture proposed in Zhang & Li (2021) (with shortest path distance encoding) cannot identify cut vertices.

Original: C. P ROOF OF T HEOREM 3. 
Revised: C. P ROOF OF T HEOREM 3.

Original: Theorem C.17.
Revised: Theorem C.17.

Original: Let G =
Revised: Let G =

Original: ( V , E G ) and H =
Revised: ( V , E G ) and H =

Original: ( V , E H ) be two graphs, and let χ G and χ H be the corresponding DSS-WL color mapping with node marking policy.
Revised: ( V , E H ) be two graphs, and let χ G and χ H be the corresponding DSS-WL color mapping with node marking policy.

Original: Then the following holds:
Revised: Then the following holds:

Original: • For any two nodes w ∈ V in G and x ∈ V in H , if χ G ( w ) =
Revised: • For any two nodes w ∈ V in G and x ∈ V in H , if χ G ( w ) =

Original: χ H ( x ) , then w is a cut vertex in graph G if and only if x is a cut vertex in graph H .
Revised: χ H ( x ) , then w is a cut vertex in graph G if and only if x is a cut vertex in graph H .

Original: • For any two edges { w 1 , w 2 } ∈ E G and { x 1 , x 2 } ∈ E H , if {{ χ G ( w 1 ) , χ G ( w 2 ) }} = {{ χ 
Revised: • For any two edges { w 1 , w 2 } ∈ E G and { x 1 , x 2 } ∈ E H , if {{ χ G ( w 1 ) , χ G ( w 2 ) }} = {{ χ H ( x χ H ( x 2 ) }} then { w w } is a edge if and only if { } is a edge

Original: Proof .
Revised: Proof .

Original: We divide the proof into two parts in Appendices C.3.1 and C.3.2, separately focusing on proving each bullet of Theorem 3.2.
Revised: We divide the proof into two parts in Appendices C.3.1 and C.3.2, separately focusing on proving each bullet of Theorem 3.2.

Original: Before going into the proof, we first define several notations.
Revised: Before going into the proof, we first define several notations.

Original: Denote χ uG ( v ) as the color of node v under the DSS-WL algorithm when marking u as a special node.
Revised: Denote χ uG ( v ) as the color of node v under the DSS-WL algorithm when marking u as a special node.

Original: By definition of DSS-WL (Line 7 in Algorithm 3), χ G ( v ) =
Revised: By definition of DSS-WL (Line 7 in Algorithm 3), χ G ( v ) =

Original: hash ( {{ χ uG ( v ) : u ∈ V}} ) .
Revised: hash ( {{ χ uG ( v ) : u ∈ V}} ) .

Original: We can similarly define the inverse mappings ( χ uG ) − 1 .
Revised: We can similarly define the inverse mappings ( χ uG ) − 1 .

Original: We first present a lemma which can help us exclude the case of disconnected graphs.
Revised: We first present a lemma which can help us exclude the case of disconnected graphs.

Original: Lemma C.18.
Revised: Lemma C.18.

Original: Given a node w , let S G ( w ) ⊂
Revised: Given a node w , let S G ( w ) ⊂

Original: V be the connected component in graph G that comprises node w .
Revised: V be the connected component in graph G that comprises node w .

Original: For any two nodes w ∈ V in G and x ∈ V in H , if χ G ( w ) =
Revised: For any two nodes w ∈ V in G and x ∈ V in H , if χ G ( w ) =

Original: χ H ( x ) , then χ G [ S G ( w )] ( w ) =
Revised: χ H ( x ) , then χ G [ S G ( w )] ( w ) =

Original: χ H [ S H ( x )] ( x ) .
Revised: χ H [ S H ( x )] ( x ) .

Original: Proof.
Revised: Proof.

Original: We first prove that if χ G ( w ) =
Revised: We first prove that if χ G ( w ) =

Original: χ H ( x ) , then {{ χ uG ( w ) : u ∈ S G ( w ) }} = {{ χ uH ( x ) : u ∈
Revised: χ H ( x ) , then {{ χ uG ( w ) : u ∈ S G ( w ) }} = {{ χ uH ( x ) : u ∈

Original: S H ( x ) }} .
Revised: S H ( x ) }} .

Original: First note that for any nodes u, w in G and v, x in H , if u ∈ S G ( w ) but v / ∈ S H ( x ) , then χ uG ( w ) ̸
Revised: First note that for any nodes u, w in G and v, x in H , if u ∈ S G ( w ) but v / ∈ S H ( x ) , then χ uG ( w ) ̸

Original: = χ vH ( x ) .
Revised: = χ vH ( x ) .

Original: This is because DSS-WL only performs neighborhood aggregation, and the marking v cannot propagate to node x while the marking u can propagate to node w .
Revised: This is because DSS-WL only performs neighborhood aggregation, and the marking v cannot propagate to node x while the marking u can propagate to node w .

Original: By definition we have
Revised: By definition we have

Original: [Equation]
Revised: [Equation]

Original: Similarly,
Revised: Similarly,

Original: [Equation]
Revised: [Equation]

Original: Since χ G ( w ) =
Revised: Since χ G ( w ) =

Original: χ H ( x ) , we have {{ χ uG : u ∈ S G ( w ) }} = {{ χ uH : u ∈ S H ( x ) }} .
Revised: χ H ( x ) , we have {{ χ uG : u ∈ S G ( w ) }} = {{ χ uH : u ∈ S H ( x ) }} .

Original: This clearly implies {{ χ uG [ S G ( w )] : u ∈ S G ( w ) }} = {{ χ uH [ S H ( x )] : u ∈ S H ( x ) }} , and thus χ G [ S G ( w )] ( w ) =
Revised: This clearly implies {{ χ uG [ S G ( w )] : u ∈ S G ( w ) }} = {{ χ uH [ S H ( x )] : u ∈ S H ( x ) }} , and thus χ G [ S G ( w )] ( w ) =

Original: χ H [ S H ( x )] ( x ) .
Revised: χ H [ S H ( x )] ( x ) .

Original: Note that w is a cut vertex in G implies w is a cut vertex in G [ S G ( w )] .
Revised: Note that w is a cut vertex in G implies w is a cut vertex in G [ S G ( w )] .

Original: Therefore, based on
Revised: Therefore, based on

Original: Lemma C.18, we can restrict our attention to subgraphs G [ S G ( w )] and H [ S H ( x )] instead of the original (potentially disconnected) graphs.
Revised: Lemma C.18, we can restrict our attention to subgraphs G [ S G ( w )] and H [ S H ( x )] instead of the original (potentially disconnected) graphs.

Original: In other words, in the subsequent proof we can simply assume that both graphs G and H are connected .
Revised: In other words, in the subsequent proof we can simply assume that both graphs G and H are connected .

Original: We next present several simple but important properties regrading the DSS-WL color mapping as well as the subgraph color mappings.
Revised: We next present several simple but important properties regrading the DSS-WL color mapping as well as the subgraph color mappings.

Original: Lemma C.19.
Revised: Lemma C.19.

Original: Let u, w be two nodes in connected graph G and v, x be two nodes in connected graph H .
Revised: Let u, w be two nodes in connected graph G and v, x be two nodes in connected graph H .

Original: Then the following holds:
Revised: Then the following holds:

Original: (a) If w = u and x ̸ = v
Revised: (a) If w = u and x ̸ = v

Original: , then χ uG ( w ) ̸
Revised: , then χ uG ( w ) ̸

Original: = χ vH ( x ) ; (b) If χ uG ( w ) =
Revised: = χ vH ( x ) ; (b) If χ uG ( w ) =

Original: χ vH ( x ) , then χ G ( w ) =
Revised: χ vH ( x ) , then χ G ( w ) =

Original: χ H ( x ) ; (c) If χ uG ( w ) =
Revised: χ H ( x ) ; (c) If χ uG ( w ) =

Original: χ vH ( x ) , then χ G ( u ) =
Revised: χ vH ( x ) , then χ G ( u ) =

Original: χ H ( v ) ; (d) χ G ( w ) =
Revised: χ H ( v ) ; (d) χ G ( w ) =

Original: χ H ( x ) if and only if χ wG ( w ) = χ
Revised: χ H ( x ) if and only if χ wG ( w ) = χ

Original: xH ( x ) ; (e) If χ u G ( w ) = χ
Revised: xH ( x ) ; (e) If χ u G ( w ) = χ

Original: v H ( x ) , then dis G ( u, w ) =
Revised: v H ( x ) , then dis G ( u, w ) =

Original: dis H ( v, x ) .
Revised: dis H ( v, x ) .

Original: Proof.
Revised: Proof.

Original: Item (a) holds because in DSS-WL, the node with marking cannot have the same color as a node without marking.
Revised: Item (a) holds because in DSS-WL, the node with marking cannot have the same color as a node without marking.

Original: This can be rigorously proved by induction over the iteration t in the
Revised: This can be rigorously proved by induction over the iteration t in the

Original: DSS-WL algorithm
Revised: DSS-WL algorithm

Original: (Line 6 in Algorithm 3).
Revised: (Line 6 in Algorithm 3).

Original: Item (b) simply follows by definition of the DSS-WL aggregation procedure since the color χ uG ( w ) encodes the color of χ G ( w ) .
Revised: Item (b) simply follows by definition of the DSS-WL aggregation procedure since the color χ uG ( w ) encodes the color of χ G ( w ) .

Original: We next prove item (c), which follows by using the WL-condition of DSS-WL algorithm (Proposition C.3).
Revised: We next prove item (c), which follows by using the WL-condition of DSS-WL algorithm (Proposition C.3).

Original: Since G is connected, there is a path from w to u .
Revised: Since G is connected, there is a path from w to u .

Original: Therefore, in graph H there is also a path from x to some node v ′ satisfying χ uG ( u ) =
Revised: Therefore, in graph H there is also a path from x to some node v ′ satisfying χ uG ( u ) =

Original: χ vH ( v ′ )
Revised: χ vH ( v ′ )

Original: (Lemma C.7).
Revised: (Lemma C.7).

Original: Now using item (a), it can only be the case v ′
Revised: Now using item (a), it can only be the case v ′

Original: = v and thus χ u G ( u ) =
Revised: = v and thus χ u G ( u ) =

Original: χ v H ( v ) .
Revised: χ v H ( v ) .

Original: Finally, by item (b) we obtain the desired result.
Revised: Finally, by item (b) we obtain the desired result.

Original: We next prove item (d).
Revised: We next prove item (d).

Original: On the one hand, item (b) already shows that χ wG ( w ) =
Revised: On the one hand, item (b) already shows that χ wG ( w ) =

Original: χ xG ( x ) =
Revised: χ xG ( x ) =

Original: ⇒ χ G ( w ) =
Revised: ⇒ χ G ( w ) =

Original: χ H ( x ) .
Revised: χ H ( x ) .

Original: On the other hand, by definition of the DSS-WL algorithm,
Revised: On the other hand, by definition of the DSS-WL algorithm,

Original: [Equation]
Revised: [Equation]

Original: Since χ G ( w ) =
Revised: Since χ G ( w ) =

Original: χ H ( x ) and χ wG ( w ) ̸
Revised: χ H ( x ) and χ wG ( w ) ̸

Original: = χ vH ( x ) holds for all v ∈ V\{ x } (by item (a)), we obtain χ wG ( w )
Revised: = χ vH ( x ) holds for all v ∈ V\{ x } (by item (a)), we obtain χ wG ( w )

Original: =
Revised: =

Original: χ xG ( x ) .
Revised: χ xG ( x ) .

Original: We finally prove item (e), which again can be derived from the WL-condition of DSS-WL algorithm.
Revised: We finally prove item (e), which again can be derived from the WL-condition of DSS-WL algorithm.

Original: If χ uG ( w ) = χ vH ( x ) , then by Corollary C.8 we have dis G ( w, ( χ uG ) − 1 ( χ uG ( u )))
Revised: If χ uG ( w ) = χ vH ( x ) , then by Corollary C.8 we have dis G ( w, ( χ uG ) − 1 ( χ uG ( u )))

Original: =
Revised: =

Original: dis H ( x, ( χ vH ) − 1 ( χ uG ( u ))) .
Revised: dis H ( x, ( χ vH ) − 1 ( χ uG ( u ))) .

Original: Using item (a), we have ( χ uG ) − 1 ( χ uG ( u ))
Revised: Using item (a), we have ( χ uG ) − 1 ( χ uG ( u ))

Original: =
Revised: =

Original: { u } and for any v ′ ̸
Revised: { u } and for any v ′ ̸

Original: = v , χ vH ( v ′ )
Revised: = v , χ vH ( v ′ )

Original: ̸
Revised: ̸

Original: = χ vH ( v ) .
Revised: = χ vH ( v ) .

Original: Therefore, it can only be the case that ( χ vH ) − 1 ( χ uG ( u ))
Revised: Therefore, it can only be the case that ( χ vH ) − 1 ( χ uG ( u ))

Original: = { v } and χ vH ( v ) =
Revised: = { v } and χ vH ( v ) =

Original: χ uG ( u ) .
Revised: χ uG ( u ) .

Original: This yields dis G ( u, w )
Revised: This yields dis G ( u, w )

Original: =
Revised: =

Original: dis G ( v, x ) and concludes the proof.
Revised: dis G ( v, x ) and concludes the proof.

Original: C.3. P ROOF FOR THE FIRST PART OF T HEOREM 3. 
Revised: C.3. P ROOF FOR THE FIRST PART OF T HEOREM 3.

Original: The following technical lemma is useful in the subsequent proof:
Revised: The following technical lemma is useful in the subsequent proof:

Original: Lemma C.20.
Revised: Lemma C.20.

Original: Let u, v ∈ V be two nodes in connected graphs G and H , respectively.
Revised: Let u, v ∈ V be two nodes in connected graphs G and H , respectively.

Original: If χ uG ( u ) = χ vH ( v ) , then {{ χ uG ( w ) : w ∈ V}} = {{ χ vH ( w ) : w ∈ V}} .
Revised: If χ uG ( u ) = χ vH ( v ) , then {{ χ uG ( w ) : w ∈ V}} = {{ χ vH ( w ) : w ∈ V}} .

Original: Proof.
Revised: Proof.

Original: Let N dG ( u ) :
Revised: Let N dG ( u ) :

Original: = { w ∈ V : dis G ( u, w ) =
Revised: = { w ∈ V : dis G ( u, w ) =

Original: d } be the d -hop neighbors of node u in graph
Revised: d } be the d -hop neighbors of node u in graph

Original: G , and denote C dG := {{ χ uG ( w ) : w ∈ N dG ( u ) }} as the multiset containing the color of all nodes w with distance d to node u .
Revised: G , and denote C dG := {{ χ uG ( w ) : w ∈ N dG ( u ) }} as the multiset containing the color of all nodes w with distance d to node u .

Original: We can similarly denote N dH ( v ) :
Revised: We can similarly denote N dH ( v ) :

Original: = { w : dis H ( v, w ) =
Revised: = { w : dis H ( v, w ) =

Original: d } and
Revised: d } and

Original: C dH = {{ χ vH ( w ) : w ∈ N dH ( v ) }} .
Revised: C dH = {{ χ vH ( w ) : w ∈ N dH ( v ) }} .

Original: It suffices to prove that for all d ∈ N + , C dG = C dH .
Revised: It suffices to prove that for all d ∈ N + , C dG = C dH .

Original: We will prove the above result by induction.
Revised: We will prove the above result by induction.

Original: The case of d = 0 is trivial.
Revised: The case of d = 0 is trivial.

Original: Now suppose the case of d is true (i.e., C dG = C dH ) and we want to prove C d +1 G =
Revised: Now suppose the case of d is true (i.e., C dG = C dH ) and we want to prove C d +1 G =

Original: C d +1 H .
Revised: C d +1 H .

Original: Note that for any nodes x 1 , xsatisfying
Revised: Note that for any nodes x 1 , xsatisfying

Original: χ uG ( x 1 ) =
Revised: χ uG ( x 1 ) =

Original: χ vH ( x 2 ) , {{ χ uG ( w ) : w ∈ N G ( x 1 ) }} = {{ χ vH ( w ) : w ∈ N H ( x 2 ) }} .
Revised: χ vH ( x 2 ) , {{ χ uG ( w ) : w ∈ N G ( x 1 ) }} = {{ χ vH ( w ) : w ∈ N H ( x 2 ) }} .

Original: Therefore, by the induction assumption C dG = C dH ,
Revised: Therefore, by the induction assumption C dG = C dH ,

Original: [Equation]
Revised: [Equation]

Original: We next claim that C dG ∩ C d ′ G = ∅ for any d ̸ = d ′ .
Revised: We next claim that C dG ∩ C d ′ G = ∅ for any d ̸ = d ′ .

Original: This is because for any nodes w 1 and w 2 with the same color χ uG ( w 1 ) =
Revised: This is because for any nodes w 1 and w 2 with the same color χ uG ( w 1 ) =

Original: χ uG ( w 2 ) , by Lemma C.19(e) we have dis G ( w 1 , u ) =
Revised: χ uG ( w 2 ) , by Lemma C.19(e) we have dis G ( w 1 , u ) =

Original: dis G ( w 2 , u ) .
Revised: dis G ( w 2 , u ) .

Original: Using this property, we obtain
Revised: Using this property, we obtain

Original: [Equation]
Revised: [Equation]

Original: It is equivalent to the following equation:
Revised: It is equivalent to the following equation:

Original: [Equation]
Revised: [Equation]

Original: ( v ) {{ χ vH ( w ) }} ×
Revised: v ) {{ χ vH ( w ) }} ×

Original: |N
Revised: |N

Original: H ( w ) ∩ N dH ( v ) | .
Revised: H ( w ) ∩ N dH ( v ) | .

Original: where {{ c }} × m is a multiset containing m repeated elements c .
Revised: where {{ c }} × m is a multiset containing m repeated elements c .

Original: Finally, observe that if χ uG ( w 1 ) =
Revised: Finally, observe that if χ uG ( w 1 ) =

Original: χ vH ( w 2 ) for some nodes w 1 and w 2 , then |N G ( w 1 ) ∩ N dG ( u ) | =
Revised: χ vH ( w 2 ) for some nodes w 1 and w 2 , then |N G ( w 1 ) ∩ N dG ( u ) | =

Original: |N H ( w 2 ) ∩ N dH ( v ) | (because
Revised: |N H ( w 2 ) ∩ N dH ( v ) | (because

Original: C dG ∩ C d ′ G = ∅ for any d ̸ = d ′ ).
Revised: C dG ∩ C d ′ G = ∅ for any d ̸ = d ′ ).

Original: Consequently, {{ χ u G ( w ) : w ∈ N d +1 G ( u ) }} = {{ χ v H ( w ) : w ∈
Revised: Consequently, {{ χ u G ( w ) : w ∈ N d +1 G ( u ) }} = {{ χ v H ( w ) : w ∈

Original: N d +1 H ( v ) }} , namely C d +1 G = C d +1 H .
Revised: N d +1 H ( v ) }} , namely C d +1 G = C d +1 H .

Original: We have thus completed the proof of the induction step.
Revised: We have thus completed the proof of the induction step.

Original: We now present the following key result, which shows an important property of the color mapping for DSS-WL:
Revised: We now present the following key result, which shows an important property of the color mapping for DSS-WL:

Original: Corollary C.21.
Revised: Corollary C.21.

Original: Let u, v ∈ V be two nodes in connected graph G with the same DSS-WL color, i.e. χ G ( u ) = χ G ( v ) .
Revised: Let u, v ∈ V be two nodes in connected graph G with the same DSS-WL color, i.e. χ G ( u ) = χ G ( v ) .

Original: Then for any color c ∈ C , {{ χ uG ( w ) : w ∈ χ − 1 G ( c ) }} = {{ χ vG ( w ) : w ∈ χ − 1 G ( c ) }} .
Revised: Then for any color c ∈ C , {{ χ uG ( w ) : w ∈ χ − 1 G ( c ) }} = {{ χ vG ( w ) : w ∈ χ − 1 G ( c ) }} .

Original: Proof.
Revised: Proof.

Original: First observe that if χ G ( u ) = χ G ( v ) , then χ uG ( u ) = χ
Revised: First observe that if χ G ( u ) = χ G ( v ) , then χ uG ( u ) = χ

Original: vG ( v ) (by Lemma C.19(d)).
Revised: vG ( v ) (by Lemma C.19(d)).

Original: Consequently, {{ χ uG ( w ) : w ∈ V}} = {{ χ vG ( w ) : w ∈ V}} holds by Lemma C.20.
Revised: Consequently, {{ χ uG ( w ) : w ∈ V}} = {{ χ vG ( w ) : w ∈ V}} holds by Lemma C.20.

Original: If {{ χ uG ( w ) : w ∈ χ − 1 G ( c ) }} ̸ = {{ χ v G ( w ) : w ∈ χ − 1 G ( c ) }} , then there must exist two nodes w 1 ∈ χ − 1 G ( c ) and w 2 / ∈ χ − 1 G ( c ) , such that χ uG ( w 1 )
Revised: If {{ χ uG ( w ) : w ∈ χ − 1 G ( c ) }} ̸ = {{ χ v G ( w ) : w ∈ χ − 1 G ( c ) }} , then there must exist two nodes w 1 ∈ χ − 1 G ( c ) and w 2 / ∈ χ − 1 G ( c ) , such that χ uG ( w 1 )

Original: =
Revised: =

Original: χ vG ( w 2 ) .
Revised: χ vG ( w 2 ) .

Original: Therefore, by Lemma C.19(b) we have χ G ( w 1 ) =
Revised: Therefore, by Lemma C.19(b) we have χ G ( w 1 ) =

Original: χ G ( w 2 ) , yielding a contradiction.
Revised: χ G ( w 2 ) , yielding a contradiction.

Original: In the subsequent proof, we assume the connected graph G is not vertex-biconnected and let u ∈ V be a cut vertex in G .
Revised: In the subsequent proof, we assume the connected graph G is not vertex-biconnected and let u ∈ V be a cut vertex in G .

Original: Let {S i } mi =1 ( m ≥ 2 ) be the partition of the vertex set V\{ u } , representing each connected component after removing node u .
Revised: Let {S i } mi =1 ( m ≥ 2 ) be the partition of the vertex set V\{ u } , representing each connected component after removing node u .

Original: [Figure]
Revised: [Figure]

Original: Lemma C.22.
Revised: Lemma C.22.

Original: There is at most one set S
Revised: There is at most one set S

Original: i satisfying S i ∩ χ − 1 G ( χ G ( u ))
Revised: i satisfying S i ∩ χ − 1 G ( χ G ( u ))

Original: ̸
Revised: ̸

Original: = ∅ .
Revised: = ∅ .

Original: In other words, if
Revised: In other words, if

Original: S i ∩ χ − 1 G ( χ G ( u )) ̸
Revised: S i ∩ χ − 1 G ( χ G ( u )) ̸

Original: = ∅ for some i ∈ [ m ] , then for any j ∈ [ m ] and j ̸
Revised: = ∅ for some i ∈ [ m ] , then for any j ∈ [ m ] and j ̸

Original: = i , S j ∩ χ − 1 G ( χ G ( u )) = ∅ .
Revised: = i , S j ∩ χ − 1 G ( χ G ( u )) = ∅ .

Original: Proof.
Revised: Proof.

Original: When | χ − 1 G ( χ G ( u )) | = 1 , the conclusion clearly holds.
Revised: When | χ − 1 G ( χ G ( u )) | = 1 , the conclusion clearly holds.

Original: If | χ − 1 G ( χ G ( u )) | > 1 , then we can pick a node u 1 ∈ χ − 1 G ( χ G ( u )) that maximizes the shortest path distance dis G ( u 1 , u ) .
Revised: If | χ − 1 G ( χ G ( u )) | > 1 , then we can pick a node u 1 ∈ χ − 1 G ( χ G ( u )) that maximizes the shortest path distance dis G ( u 1 , u ) .

Original: Let u 1 ∈ S
Revised: Let u 1 ∈ S

Original: i for some i ∈ [ m ] .
Revised: i for some i ∈ [ m ] .

Original: If the lemma does not hold, then we can pick another node u 2 ∈ χ − 1 G ( χ G ( u )) and u 2 / ∈ S i .
Revised: If the lemma does not hold, then we can pick another node u 2 ∈ χ − 1 G ( χ G ( u )) and u 2 / ∈ S i .

Original: Since u 1 and u 2 are in different connected component after removing u , dis G ( u 1 , u 2 )
Revised: Since u 1 and u 2 are in different connected component after removing u , dis G ( u 1 , u 2 )

Original: =
Revised: =

Original: dis G ( u 1 , u ) + dis G ( u 2 , u ) .
Revised: dis G ( u 1 , u ) + dis G ( u 2 , u ) .

Original: See Figure 4(a) for an illustration of this paragraph.
Revised: See Figure 4(a) for an illustration of this paragraph.

Original: By Corollary C.21, {{ χ u 1 G ( w ) : w ∈ χ − 1 G ( χ G ( u )) }} = {{ χ uG ( w ) : w ∈ χ − 1 G ( χ G ( u )) }} .
Revised: By Corollary C.21, {{ χ u 1 G ( w ) : w ∈ χ − 1 G ( χ G ( u )) }} = {{ χ uG ( w ) : w ∈ χ − 1 G ( χ G ( u )) }} .

Original: Therefore, there must exist a node u 3 ∈ χ − 1 G ( χ G ( u )) satisfying χ u 1 G ( u 2 ) =
Revised: Therefore, there must exist a node u 3 ∈ χ − 1 G ( χ G ( u )) satisfying χ u 1 G ( u 2 ) =

Original: χ uG ( u 3 ) .
Revised: χ uG ( u 3 ) .

Original: We thus have dis G ( u 2 , u 1 ) =
Revised: We thus have dis G ( u 2 , u 1 ) =

Original: dis G ( u 3 , u ) by Lemma C.19(e).
Revised: dis G ( u 3 , u ) by Lemma C.19(e).

Original: On the other hand, by definition of the node u 1 , dis G ( u 1 , u ) ≥ dis G ( u 3 , u ) .
Revised: On the other hand, by definition of the node u 1 , dis G ( u 1 , u ) ≥ dis G ( u 3 , u ) .

Original: Therefore, dis G ( u 2 , u 1 ) =
Revised: Therefore, dis G ( u 2 , u 1 ) =

Original: dis G ( u 1 , u ) + dis G ( u 2 , u ) >
Revised: dis G ( u 1 , u ) + dis G ( u 2 , u ) >

Original: dis G ( u 3 , u ) .
Revised: dis G ( u 3 , u ) .

Original: This yields a contradiction and concludes the proof.
Revised: This yields a contradiction and concludes the proof.

Original: Lemma C.23.
Revised: Lemma C.23.

Original: For all u ′ ∈ χ − 1 G ( χ G ( u )) , u ′ it is a cut vertex of G .
Revised: For all u ′ ∈ χ − 1 G ( χ G ( u )) , u ′ it is a cut vertex of G .

Original: Proof.
Revised: Proof.

Original: When | χ − 1 G ( χ G ( u )) | = 1 , the conclusion clearly holds.
Revised: When | χ − 1 G ( χ G ( u )) | = 1 , the conclusion clearly holds.

Original: Now assume | χ − 1 G ( χ G ( u )) | > 1 .
Revised: Now assume | χ − 1 G ( χ G ( u )) | > 1 .