Abstract 1 Introduction 2 Preliminaries 3 Finite Variable Counting Logics with Restricted Requantification 4 The Role of Reusability 5 Space Complexity 6 Graphs Identified by Logics with Restricted Requantification 7 Outlook References

Finite Variable Counting Logics with Restricted Requantification

Simon Raßmann ORCID TU Darmstadt, Germany Georg Schindling ORCID TU Darmstadt, Germany Pascal Schweitzer ORCID TU Darmstadt, Germany
Abstract

Counting logics with a bounded number of variables form one of the central concepts in descriptive complexity theory. Although they restrict the number of variables that a formula can contain, the variables can be nested within scopes of quantified occurrences of themselves. In other words, the variables can be requantified. We study the fragments obtained from counting logics by restricting requantification for some but not necessarily all the variables.

Similar to the logics without limitation on requantification, we develop tools to investigate the restricted variants. Specifically, we introduce a bijective pebble game in which certain pebbles can only be placed once and for all, and a corresponding two-parametric family of Weisfeiler-Leman algorithms. We show close correspondences between the three concepts.

By using a suitable cops-and-robber game and adaptations of the Cai-Fürer-Immerman construction, we completely clarify the relative expressive power of the new logics.

We show that the restriction of requantification has beneficial algorithmic implications in terms of graph identification. Indeed, we argue that with regard to space complexity, non-requantifiable variables only incur an additive polynomial factor when testing for equivalence. In contrast, for all we know, requantifiable variables incur a multiplicative linear factor.

Finally, we observe that graphs of bounded tree-depth and 3-connected planar graphs can be identified using no, respectively, only a very limited number of requantifiable variables.

Keywords and phrases:
Requantification, Finite variable counting logics, Weisfeiler-Leman algorithm
Copyright and License:
[Uncaptioned image] © Simon Raßmann, Georg Schindling, and Pascal Schweitzer; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Finite Model Theory
; Theory of computation Complexity theory and logic
Related Version:
Full Version: https://arxiv.org/abs/2411.06944
Funding:
The research of the second and third author leading to these results has received funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (EngageS: grant agreement No. 820148).
Editors:
Jörg Endrullis and Sylvain Schmitz

1 Introduction

Descriptive complexity is a branch of finite model theory that essentially aims at characterizing how difficult logical expressions need to be in order to capture particular complexity classes. While we are yet to find or rule out a logic capturing the languages in the complexity class P, there is an extensive body of work regarding the descriptive complexity of problems within P. Most notably, there is the work of Cai, Fürer, and Immerman [3] which studies a particular fragment of first-order logic. This is the fragment 𝖢k in which counting quantifiers are introduced into the logic, but the number of variables is restricted to being at most k. The seminal result in [3] shows that this logic fails to define certain graphs up to isomorphism, which in turn proves that inflationary fixed-point logic with counting IFP+C fails to capture P.

Although the fragment 𝖢k restricts the number of variables, it is common for variables to be reused within a single logical formula. In particular, variables can be nested within scopes of quantified occurrences of themselves. In other words, they can be requantified. In our work, we are interested in understanding what happens if we limit the ability to reuse variables through requantification. In fact, we may think of reusability as a resource (in the vein of time, space, communication, proof length, advice etc.) that should be employed economically.

It turns out that the ability to limit requantification provides us with a more detailed lens into the landscape of descriptive complexities within P, much in the fashion of fine-grained complexity theory.

Results and techniques.

Let us denote by 𝖢(k1,k2) the fragment of first-order logic with counting quantifiers in which the formulas have at most k1 variables that may be requantified and at most k2 variables that may not be requantified.

First, we show that many of the traditional techniques of treating counting logics can be adapted to the setting of limited requantification. Specifically, it is well known that there is a close ternary correspondence between the logic 𝖢k, the combinatorial bijective k-pebble game, and the famous (k1)-dimensional Weisfeiler-Leman algorithm [3, 22, 26]. We develop versions of the game and the algorithm that also have a limit on the reusability of resources. For the pebble game, a limit on requantification translates into pebbles that cannot be picked up anymore, once they have been placed. For the Weisfeiler-Leman algorithm, the limit on requantification translates into having some dimensions that “cannot be reused”. In fact the translation to the algorithmic viewpoint is not as straightforward as one might hope at first. Indeed, we do not know how to define a restricted version of the classical Weisfeiler-Leman algorithm that corresponds to the logic 𝖢(k1,k2). However, we circumvent this problem by employing the oblivious Weisfeiler-Leman algorithm (OWL). This variant is often used in the context of machine learning. In fact, Grohe [17] recently showed that k+1-dimensional OWL is in fact exactly as powerful as k-dimensional (classical) WL. We develop a resource-reuse restricted version of the oblivious algorithm and prove equivalence to our logic. Indeed, we formally prove precisely matching correspondences between the limited requantification, limited pebble reusability, and the limited reusable dimensions (Theorem 6).

Next, we conclusively clarify the relation between the logics within the two-parametric family 𝖢(k1,k2). We show that in most cases limiting the requantifiability of a variable strictly reduces the power of the logic. We argue that no amount of requantification-restricted variables is sufficient to compensate the loss of an unrestricted variable. However, these statements are only true if at least some requantifiable variable remains. In fact, exceptionally, 𝖢(1,k2) is strictly less expressive than 𝖢(0,k2) whenever k2>2k2 (Theorem 13). To show the separation results, we adapt a construction of Fürer [13] and develop a cops-and-robber game similar to those in [12, 19]. In this version, some of the cops may repeatedly change their location, while others can only choose a location once and for all. Using another graph construction, we rule out various a priori tempting ideas concerning normal forms in 𝖢(k1,k2). To this end we show that formulas in the logics can essentially become as complicated as possible, having to repeatedly requantify all of the requantifiable variables an unbounded number of times, before using a non-requantifiable variable (Corollary 16). In terms of the pebble game, it seems a priori unclear when an optimal strategy would employ the non-reusable pebbles. However, the corollary says that in general one has to conserve the non-reusable pebbles for possibly many moves until a favorable position calls for them.

Having gone through the technical challenges that come with the introduction of reusability, puts us into a position to discuss the implications. Indeed, as our main result, we argue that our finer grained view on counting logics through restricted requantification has beneficial algorithmic implications. Specifically, we show that equivalence with respect to the logic 𝖢(k1,k2) can be decided in polynomial time with a space complexity of O(nk1logn), hiding quadratic factors depending only on k1 and k2 (Theorem 24). This shows that while the requantifiable variables each incur a multiplicative linear factor in required space, the restricted variables only incur an additive polynomial factor. In particular, equivalence with respect to the logics 𝖢(0,k2) can be decided in logarithmic space. To show these statements, we leverage the fact that, because non-requantifiable variables cannot simultaneously occur free and bound, the 𝖢(k1,k2)-type of a variable assignment does not depend on the 𝖢(k1,k2)-type of assignments which disagree regarding non-requantifiable variables. Moreover, we use ideas from an algorithm of Lindell, which computes isomorphism of trees in logarithmic space [30] to implement the iteration steps of our algorithm. Generally, we believe the new viewpoint may be of interest in particular for applications in machine learning, where the WL-hierarchy appears to be too coarse for actual applications with graph neural networks (see for example [1, 2, 31, 40]). In the process of the space complexity proof, we also show that the iteration number of the resource-restricted Weisfeiler-Leman algorithm described above is at most (k2+1)nk11 (Corollary 19).

Justifying the new concepts of restricted reusability, we observe that there are interesting graph classes that are identified by the logics 𝖢(k1,k2). We argue that 𝖢(0,d+1) identifies all graphs of tree-depth at most d (Theorem 27) and that 𝖢(2,2) identifies all 3-connected planar graphs (Theorem 33).

Outline of the paper.

After briefly providing necessary preliminaries (Section 2) we formally introduce the logics 𝖢(k1,k2), the pebble game with non-reusable pebbles, the (k1,k2)-dimensional oblivious Weisfeiler-Leman algorithm, and prove the correspondence theorem between them (Section 3). We then relate the power of the logics to each other and rule out certain normal forms (Section 4). We then analyze the space complexity (Section 5) and finally provide two classes of graphs that are identified by our logics (Section 6).

Further related work.

In addition to the references above, let us mention related investigations. Over time, a large body of work on descriptive complexity has evolved. For insights into fundamental results regarding bounded variable logics, we refer to classic texts [25, 26, 33, 34]. However, highlighting the importance of the counting logics 𝖢k, let us at least mention the Immerman-Vardi theorem [24, 39]. It says that on ordered structures, least fixed-point logic LFP captures P. Since LFP has the same expressive power as IFP+C on ordered structures, also IFP+C, whose expressive power is closely related to the expressive power of the logics 𝖢k, captures P. We should also mention the work of Hella [22] introducing the bijective k-pebble game which forms the basis for our resource restricted versions.

(Counting logics on graph classes)

Because of the close correspondence between the logic 𝖢k and the (k1)-dimensional Weisfeiler-Leman algorithm, our investigations are closely related to the notion of the Weisfeiler-Leman dimension of a graph defined in [15]. Given a graph G this is the least number of variables k such that 𝖢k+1 identifies G. In particular, on every graph class of bounded Weisfeiler-Leman dimension, the corresponding finite variable counting logic captures isomorphism. Graph classes with bounded Weisfeiler-Leman dimension include graphs with a forbidden minor [14] and graphs of bounded rank-width (or equivalently clique width) [20], which in both cases is also shown to imply that IFP+C captures P on these classes. For a comprehensive survey we refer to [27]. Our observations for planar graphs follow from techniques bounding the number of variables required for the identification of planar graphs [28]. Other recent classes not already captured by the results on excluded minors and rank-width include, for example, some polyhedral graphs [29], some strongly regular graphs [4], and permutation graphs [21].

(Logic and tree decompositions)

In [9] and independently [8] it was shown that 𝖢k-equivalence is characterized by homomorphism counts from graphs of tree-width at most k1. Likewise, homomorphism counts from bounded tree-depth graphs characterize equivalence in counting logic of bounded quantifier-rank [16]. Recently, these results were unified to characterize logical equivalence in finite variable counting logics with bounded quantifier-rank in terms of homomorphism counts [12].

(Space complexity)

Ideas underlying Lindell’s logspace algorithm for tree isomorphism have also been used in the context of planar graphs [6] and more generally bounded genus graphs [10]. Similar results exist for classes of bounded tree-width [5, 11].

(Further recent results)

Let us mention some quite recent results in the vicinity of our work that cannot be found in the surveys mentioned above. Regarding the quantifier-rank within counting logics, there is a recent superlinear lower bound [19] improving Fürer’s linear lower bound construction [13]. Further, very recent work on logics with counting includes results on rooted unranked trees [23] and inapproximability of questions on unique games [35]. Finally, there has been a surge in research on descriptive complexity within the context of machine learning (see [17, 36, 37]).

2 Preliminaries

General notation.

For n+ we use [n] to denote the n-element set {1,,n}. We use the notation {{v1,,vn}} for multisets. For k1,k2+, we fix the variable sets [xk1]{x1,,xk1}, [yk2]{y1,,yk2}, and [xk1,yk2]{x1,,xk1,y1,,yk2}. Given a set V, a partial function α:[xk1,yk2]V assigns to every variable z[xk1,yk2] at most one element α(z)V. If α does not assign an element to z, we write α(z)=. Also, we write im(α) for the image of α. With a finite set V and α:[xk1,yk2]V we associate the total function α¯:[xk1,yk2]V˙{}, which we also view as a [xk1,yk2]-indexed (k1+k2)-tuple. For z[xk1,yk2] and vV, the function α[z/v] is defined as α but with α(z) replaced by v.

Graphs.

A graph is a pair G=(V(G),E(G)) consisting of a finite set V(G) of vertices and a set E(G)(V(G)2) of edges. We write |G| for the number of vertices, called the order of G. For a vertex vV(G) we define the neighborhood NG(v){wV(G):{v,w}E(G)} and the degree dG(v)|NG(v)| of v in G. We call v universal in G if NG(v)=V(G){v}. A colored graph consists of a graph G and a coloring function χ:V(G)C with a finite, ordered set C of colors. For a colored graph G and vertices v1,,vnV(G) the graph G(v1,,vn) is obtained by assigning new and distinct colors to the vertices v1,,vn in G. The vertices v1,,vn are then called individualized. An isomorphism of (colored) graphs G and H is a bijection φ:V(G)V(H) that preserves edges, non-edges, and vertex-colors.

We denote the complete graph on n vertices by Kn, that is, the graph with vertex set [n] and all possible edges included. A star of degree n is a graph consisting of one universal vertex of degree n and its neighbors of degree 1.

First-order logic with counting.

First-order logic with counting 𝖢 is an extension of first-order logic by counting quantifiers k for all k. These intuitively state that there exist at least k distinct vertices satisfying the formula that follows.

Over the language of colored graphs with variable set 𝒱, formulas are inductively built up from atomic formulas (for stating equality or adjacency of vertices as well as for stating that a vertex has a given vertex color) via negation (¬), conjunction (), disjunction (), implication (), and quantification over vertices via , and the counting quantifiers k. For a colored graph G, a variable assignment α:𝒱V(G), and a formula φ𝖢, we write G,αφ if the graph G together with the variable assignment α satisfies the formula φ.

The quantifier-rank qr(φ) of a formula φ is the maximum depth of nested quantifiers in the formula. The set of free variables free(φ) of a formula φ is defined as the set of all variables that occur outside the scope of a corresponding quantifier in φ. If free(φ)= the formula φ is called a sentence. The set of bound variables bound(φ) is the set of all variables that occur quantified in φ. If we restrict to a finite set of k+ variables, the resulting logic is called k-variable counting logic and denoted by 𝖢k. For r the quantifier-rank-r counting logic 𝖢r is obtained by restricting formulas in 𝖢 to quantifier-rank at most r. The k-variable quantifier-rank-r counting logic is defined as 𝖢rk𝖢k𝖢r.

As a general reference on finite variable logics, we refer to [33].

The Weisfeiler-Leman algorithm.

Let k1 and G be a colored graph. The k-dimensional Weisfeiler-Leman algorithm (short k-WL) iteratively computes a coloring of the k-tuples of vertices of G. We also view the k-tuples as total functions α¯:{x1,,xk}V(G). Initially, each tuple α¯V(G)k is colored by wlk(0)(G,α¯)atpk(G,α¯). Here, atpk(G,α¯) is the atomic type of α¯ in G, i.e., the set of all atomic formulas with variables in {x1,,xk} satisfied by the colored graph G[im(α)] together with the assignment α. For every r, we then inductively set

wlk(r+1)(G,α¯)(wlk(r)(G,α¯);{{(wlk(r)(G,α¯[xi/u]))i[k]:uV(G)}})

whenever k2, but for the case k=1 we set

wlk(r+1)(G,α¯)(wlk(r)(G,α¯);{{wlk(r)(G,u):uNG(α¯)}}).

We write wlk(r)(G) for the coloring of all k-tuples of vertices of G assigning wlk(r+1)(G,α¯) to α¯. Since the definition of wlk(r+1)(G,α¯) includes the color wlk(r)(G,α¯) of the previous iteration, the coloring wlk(r+1)(G) refines the coloring wlk(r)(G). That is, whenever wlk(r+1)(G,α1¯)=wlk(r+1)(G,α2¯) for α1¯,α2¯V(G)k, then we also have wlk(r)(G,α1¯)=wlk(r)(G,α2¯). Since there are exactly |V(G)|k-many k-tuples of vertices, there exists an r<|V(G)|k such that wlk(r)(G) induces the same partition of color classes as wlk(r+1)(G). It follows from the definition of the refinement that this implies wlk(r)(G) induces the same partition as wlk(r)(G) for all rr. In this case we say that k-WL stabilizes after at most r iterations on the graph G. If r is minimal with this property, we write wlk()(G)wlk(r+1)(G) and call wlk()(G) the stable coloring. For a second colored graph H, we say that k-WL distinguishes G and H after r iterations if there exists a color c such that |{α¯V(G)k:wlk(r)(G,α¯)=c}||{β¯V(H)k:wlk(r)(H,β¯)=c}|.

Besides the classical k-dimensional Weisfeiler-Leman algorithm, there also exists a variant, called the (k+1)-dimensional oblivious Weisfeiler-Leman algorithm (short (k+1)-OWL). This variant colors (k+1)-tuples of vertices, which we again view as total functions α¯:{x1,,xk+1}V(G). Initially, all tuples are colored by their atomic type: owlk+1(0)(G,α¯)atpk+1(G,α¯). Then, this coloring is iteratively refined by setting

owlk+1(r+1)(G,α¯)(owlk+1(r)(G,α¯);{{owlk+1(r)(G,α¯[xi/u]):uV(G)}}i[k+1]).

The stable coloring owlk+1()(G) and the notion of distinguishing graphs is defined as for k-WL.

It turns out that k-WL and (k+1)-OWL have the same distinguishing power.

Lemma 1 ([17, Lemma A.1, Corollary V.7]).

Let G and H be graphs, α¯V(G)k+1 and β¯V(H)k+1. Then the following are equivalent for every r:

  1. 1.

    owlk+1(r)(G,α¯)=owlk+1(r)(H,β¯),

  2. 2.

    atpk+1(G,α¯)=atpk+1(H,β¯) and for all i[k+1], we have wlk(r)(G,α¯i)=wlk(r)(H,β¯i), where α¯i is the k-tuple obtained from α by deleting the i-th entry.

Moreover, two graphs are distinguished by k-WL if and only if they are distinguished by (k+1)-OWL.

3 Finite Variable Counting Logics with Restricted Requantification

When working in the logic 𝖢k, it is often necessary to requantify variables in order to express certain properties. We introduce finite variable first-order logic with counting quantifiers and restricted requantification to study this issue. We then define an Ehrenfeucht-Fraïssé-style game as an important tool for the analysis of the newly introduced logic by game-theoretic arguments. Finally, we devise a variant of k-OWL that precisely captures the expressive power of the logic and game and prove a characterization that closely ties the reusable and non-reusable resources among these objects. First, we give a precise definition of requantification.

Definition 2.

Consider the counting logic 𝖢 over a set of variables 𝒱. A variable x𝒱 is said to be requantified in a formula φ𝖢 if either xfree(φ)bound(φ) or if there exist a subformula Qxψ of φ and in turn a subformula Qxχ of ψ with Q,Q{,}{n:n}. We define the logic 𝖢(k1,k2) as the fragment of 𝖢 over the fixed variable set 𝒱=[xk1,yk2] consisting of those formulas in which the variables from {y1,,yk2} are not requantified. The fragment of 𝖢(k1,k2) with quantifier-rank at most r is denoted by 𝖢r(k1,k2).

Example 3.

Consider the following 𝖢3(2,1) formula:

(y1¬E(x2,y1))4x1(E(x2,x1)y1(¬E(x1,y1))x2(¬E(x2,x1)3x1E(x1,x2)))

expressing that the vertex x2 is not universal and has at least four non-universal neighbors such that every non-neighbor of those has degree at least three. The variable x2 is requantified in this formula since it occurs free and bound. The variable x1 is requantified because the subformula 3x1E(x1,x2) occurs within the scope of the outermost quantification 4x1. The variable y1 however is not requantified since neither of its quantifications occurs in the scope of the other.

The central question we will investigate in the following is how the non-requantifiability restriction affects the expressive power of the logic 𝖢(k1,k2). To this end, we use the notation 𝖢(k1,k2)𝖢(k1,k2) if every pair of graphs distinguished by 𝖢(k1,k2) is also distinguished by 𝖢(k1,k2). We also write 𝖢(k1,k2)𝖢(k1,k2) if the two logics distinguish exactly the same pairs of graphs and 𝖢(k1,k2)𝖢(k1,k2) if the relation is strict. In the case of unrestricted requantification (i.e. k2=0) it is clear that 𝖢(k1,0)𝖢(k1+1,0). In this terminology, the central result of [3] is that this relation is strict for all k1. For the case of restricted requantification we make the simple observation that having more variables is at least as expressive as having fewer variables (independent of their ability to be requantified). We also observe that requantifiable variables are at least as expressive as non-requantifiable variables. That is, for all k1,k2 with k1+k21 it holds that 𝖢(k1,k2)𝖢(k1,k2+1)𝖢(k1+1,k2).

Also, observe that having only non-requantifiable variables (i.e. k1=0) bounds the quantifier-rank to at most k2 and in turn every sentence of quantifier-rank at most k2 can be rewritten using at most k2 non-requantifiable variables. More precisely, we have 𝖢(0,k2)𝖢k2.

Next, we establish an Ehrenfeucht-Fraïssé-style game which closely corresponds to the power of the previously defined logics with respect to distinguishing graphs. The game is a variant of the bijective pebble game introduced in [22] with the additional restriction that some pebbles may not be picked up again once placed.

Definition 4.

Suppose k1,k2 and k1+k21. For colored graphs G and H, we define the bijective (k1,k2)-pebble game BP(k1,k2)(G,H) as follows:

The game is played by the players Spoiler, denoted by (S), and Duplicator, denoted by (D), with one pair of pebbles for each variable in [xk1,yk2]. The pebble pairs in [xk1] are called reusable and the pebble pairs in [yk2] are called non-reusable.

The game proceeds in rounds, each of which is associated with a pair of partial functions α:[xk1,yk2]V(G), β:[xk1,yk2]V(H) with dom(α)=dom(β). We call such a pair of partial functions a (k1,k2)-configuration on the pair G,H. These functions indicate the placement of the pebble pairs on the graphs. For a pebble pair z[xk1,yk2] and vertices vV(G),wV(H) we have α(z)=v,β(z)=w whenever the two pebbles of the pair z are placed on v and w, respectively. If not specified otherwise, both games start from the empty configuration given by dom(α)=dom(β)=. One round of the game with current configuration (α,β) consists of the following steps:

  1. 1.

    (S) picks up a pebble pair z[xk1,yk2] such that z[xk1] or α(z) is undefined. If no such z exists, the winning condition is checked directly.

  2. 2.

    (D) chooses a bijection f:V(G)V(H).

  3. 3.

    (S) chooses wV(G) and f(w)V(H) to be pebbled with the pair z.

  4. 4.

    The new configuration is given by (α[z/w],β[z/f(w)]).

The winning conditions are as follows:

  • (S) wins immediately, if the initial configuration (α,β) does not induce a partial isomorphism. That is, the function h:im(α)im(β),α(z)β(z) is not a graph isomorphism from G[im(α)] to H[im(β)].

  • (S) wins if (D) cannot choose a bijection f, i.e., if |G||H|.

  • (S) wins after the current round if the configuration (α,β) does not induce a partial isomorphism. Otherwise, the game continues and (D) wins the game if (S) never wins a round.

For r+ we define the game variant BP(k1,k2)r, which has the additional winning condition that (D) wins the game if (S) does not win after r rounds.

We now turn to devise an algorithmic counterpart of the logic 𝖢(k1,k2) and the game BP(k1,k2). It is an adaptation of the oblivious Weisfeiler-Leman algorithm k-OWL.

Indeed, to capture 𝖢(k1,k2)-equivalence, we iteratively color (partial) (k1+k2)-tuples of vertices of a given graph with the previous color, and a sequence of multisets corresponding to variables as in k1-OWL. We deviate from the classical oblivious Weisfeiler-Leman algorithm by treating some entries of the tuple as non-reusable: For y[yk2] with α(y), the variable y is already assigned in the logic, respectively the non-reusable pebble is already placed in the game. Thus, the entry in α corresponding to this variable should not be replaced by other vertices, but be kept fixed. For this reason we utilize the advantage of oblivious Weisfeiler-Leman that each multiset corresponds to exactly one variable and pebble pair respectively.

Recall that we can view a variable assignment α:[xk1,yk2]V(G) for a graph G as a [xk1,yk2]-indexed (k1+k2)-tuple over V(G)˙{}, which we denote by α¯. For a variable assignment α, we set J(α){j[k2]:α¯(yj)=}.

Definition 5.

Let G be a graph and k1,k2 with k1+k21. The (k1,k2)-dimensional oblivious Weisfeiler-Leman algorithm (short (k1,k2)-OWL) iteratively computes a coloring of [xk1,yk2]-indexed (k1+k2)-tuples over V(G)˙{}.

Initially, each tuple α¯ is colored by its atomic type in G: owl(k1,k2)(0)(G,α¯)atpk1+k2(G,α¯). This coloring is then refined recursively: for every r, we define

owl(k1,k2)(r+1)(G,α¯)(owl(k1,k2)(r)(G,α¯), {{owl(k1,k2)(r)(G,α¯[xi/w]):wV(G)}}i[k1],
{{owl(k1,k2)(r)(G,α¯[yj/w]):wV(G)}}jJ(α))

Just as in the classical case, the coloring owl(k1,k2)(r+1)(G) refines owl(k1,k2)(r)(G) and eventually stabilizes. We denote the stable coloring by owl(k1,k2)()(G).

The correspondence of counting logic, pebble game, and algorithm for restricted reusability now is as follows:

Theorem 6.

Let G,H be colored graphs and k1,k2 with k1+k21. Then for all (k1,k2)-configurations (α,β) and r the following are equivalent:

  1. 1.

    For every φ𝖢r(k1,k2) with free(φ)dom(α) and free(φ)[yk2]=dom(α)[yk2] it holds that G,αφH,βφ.

  2. 2.

    (D) has a winning strategy for BP(k1,k2)r(G,H) with initial configuration (α,β).

  3. 3.

    It holds that owl(k1,k2)(r)(G,α¯)=owl(k1,k2)(r)(H,β¯).

The theorem can be proved by carefully adapting the proof of [3, Theorem 5.2] by treating non-requantifiable variables separately.

4 The Role of Reusability

We investigate the interplay of requantifiable and non-requantifiable variables in 𝖢(k1,k2) using the game-theoretic characterization provided by Theorem 6. To this end, we utilize the CFI construction from [3] in the variant employed in [13]. The construction starts from a so-called base graph, that is, a connected and colored graph such that every vertex receives a unique natural number as color. By our convention, the coloring induces a linear ordering on the vertices of the base graph. The vertices and edges of the base graph are called base vertices and base edges, respectively. From a base graph G the CFI graph X(G) is constructed by replacing each base vertex in G by a gadget consisting of gadget vertices but not edges. Gadgets corresponding to adjacent base vertices are then connected by adding edges between gadget vertices. To twist a base edge {u,v}E in X(G) means to replace every edge between the corresponding gadgets by a non-edge and every non-edge by an edge. The twisted CFI graph X~(G) is obtained by twisting an arbitrary base edge eE(G) in X(G).

We introduce a variant of the cops-and-robber game used in [19] to simulate the game BP(k1,k2) on CFI graphs via a game played only on the base graph. Our variant involves non-reusable cops as a way of restricting reusability of resources.

Definition 7.

The cops-and-robber game CR(k1,k2)(G) is played on a base graph G between a group of k1+k2 cops and one robber. The cops are denoted by the elements of [xk1,yk2] and a cop xi is called reusable while a cop yj is called non-reusable. Each round of the game is associated with a partial function γ:[xk1,yk2]V(G) and an edge eE(G). The function γ encodes the current positions of the cops while the edge e is the position of the robber. Initially, there are no cops on the vertices and the robber is placed on some edge of the base graph. One round of the game with current position (γ,e) consists of the following steps:

  1. 1.

    The cops choose z[xk1,yk2] such that z[xk1] or γ(z) is undefined. If no such z exists, the winning condition is checked directly. Then a destination wV(G) for z is declared.

  2. 2.

    The robber chooses an edge e in the connected component of e in Gim(γ[z/]).

  3. 3.

    The cop z is placed on the vertex w.

  4. 4.

    The new position of the game is given by (γ[z/w],e).

The winning condition is as follows:

  • The cops win the game if at the end of the current round both vertices incident to the robber edge e hold cops. The robber wins if the cops never win.

We also introduce the game CR(k1,k2)r(G) with the additional winning condition that the robber wins if the cops do not win in r rounds.

Intuitively, in the game BP(k1,k2)(X(G),X~(G)) Spoiler has to catch the twist in X~(G) with pebbles to show the difference of the graphs. This corresponds to moving the cops (according to the reusability of the used pebbles) in CR(k1,k2)(G). Duplicator, however, moves the twist in X~(G) using automorphisms of the graph to hide the difference, which corresponds to moving the robber in CR(k1,k2)(G). Following similar arguments from [7, 13], this yields the following lemma, stating that the bijective pebble game on CFI graphs can be simulated appropriately.

Lemma 8.

Let k1+k22 and r. Then the robber has a winning strategy in CR(k1,k2)r(G) if and only if (D) has a winning strategy in BP(k1,k2)r(X(G),X~(G)).

We now prove a strict hierarchy for the logics 𝖢(k1,k2) by providing, for every pair of logics we want to separate, two CFI graphs X(G),X~(G) that are distinguished by one of the logics, but not the other. To show this, it now suffices to provide strategies for the game CR(k1,k2)(G) by Lemma 8 and Theorem 6. The idea for the choice of the base graphs G is inspired by [13] where grid graphs were chosen as base graphs.

Definition 9.

The graph

Gh×({vi,j:i[h],j[]},{{vi,j,vr,s}:|ir|+|js|=1})

is called the grid graph with h rows and columns. We also call h the height and the length of the grid. We say that the cops build a barrier in the game CR(k1,k2) played on a graph G containing a grid if they are placed on a separator of the graph G disconnecting the first column from the last column of the grid.

First, we show the advantages of reusability: When the cops-and-robber game is played on the grid graph Gh× with at least h+1 cops, the cops can be placed on a column to form a barrier and move it through the grid maintaining this formation by using the additional cop. To show the separation, we choose the base graph as a grid of sufficient length such that the cops are required to move or build a barrier repeatedly. This makes reusability necessary as all non-reusable cops are placed at some point and cannot be used to move a barrier any further.

Lemma 10.

For all k1,k2,k1,k20, if k1>max(k1,1), then 𝖢(k1,k2)𝖢(k1,k2).

Proof.

First, consider the game CR(k1,k2)(G(k11)×(k122k2+1)). The cops can build a barrier in the middle of the grid and move it towards the robber only using reusable cops. This is a winning strategy for the cops since the size of the component containing the robber is decreased by a constant in each round and eventually vanishes. On the other hand, we show that the robber has a winning strategy in the game CR(k1,k2)(G(k11)×(k122k2+1)) by induction on k2. The base case for k2=0 is the game CR(k1,0)(G(k11)×(k1+1)), for which the robber has a winning strategy as a barrier can be built, but not moved. For the inductive step assume k2>0 and consider the game CR(k1,k2+1)(G(k11)×(k122k2+2+1)). Using only reusable cops, the cops can reduce the size of the robber component with a barrier. However, the size remains at least (k11)(k122k2+1+1), since the robber can choose the larger induced component. When a reusable cop is reused before a non-reusable cop was used to build another barrier, the reusable barrier breaks down and the robber as an escape strategy. Using non-reusable cops, the cops can build another wall to reduce the size of the robber component to (k11)(k122k2+1). Again, the robber chooses the larger induced component. But now the remaining game is CR(k1,k2k1+2)(G(k11)×(k122k2+1)) and we have k2k2k1+2. Thus, by the inductive hypothesis the robber has a winning strategy for the remaining game.

Second, we show the advantages of mere capacity: When the base graph is chosen as a complete graph, the robber can choose any edge independently of the choice of vertices by the cops and the only possibility to win for the cops is to have sufficient capacity. In this case, capacity is more valuable than reusability.

Lemma 11.

For all k1,k2,k1,k20, if k1+k2>k1+k2, then 𝖢(k1,k2)𝖢(k1,k2).

Proof.

In the game CR(k1,k2)(Kk1+k2), the cops have a winning strategy just by covering all base vertices. In contrast, in the game CR(k1,k2)(Kk1+k2) the robber has a winning strategy. Whenever a cop is picked up there is one edge that is not incident to a cop and thus yields a safe escape for the robber.

Third, we treat the special case of a single requantifiable variable: Intuitively, at least two reusable cops are needed to move a barrier for an arbitrarily large distance in a base graph. When only one single reusable cop is available, the distance that can be covered by a barrier of cops is bounded by 2k1+1 because for every other move a non-reusable cop must be used. The perfect binary tree of depth d is the binary tree Bd such that all interior vertices have two children and all leaves have the same depth.

Lemma 12.

For all k2,k21 it holds that 𝖢(1,k2)𝖢(0,k2) if and only if k22k2.

Proof.

In the game CR(1,k2)(B2k2), the cops have a winning strategy by alternately using non-reusable cops and the reusable cop. In the game CR(0,2k2)(B2k2) the robber has a winning strategy as the non-reusable cops are exhausted before the robber is caught. This yields 𝖢(1,k2)𝖢(0,2k2). For k22k2 we get 𝖢(1,k2)𝖢(0,k2) since the robber wins with the same strategy in CR(0,k2)(B2k2). For k2>2k2, let (S) have a winning strategy for BP(1,k2)(G,H). Then (S) has a winning strategy for BP(1,k2)2k2+1(G,H) since consecutive moves involving the pebble pair x1 can be replaced by a single move instead. The winning strategy for (S) in BP(1,k2)2k2+1(G,H) directly yields a winning strategy for (S) in BP(0,k2)(G,H): For every pebble pair played by (S) in BP(1,k2)2k2+1(G,H), the player (S) can use a new pair in BP(0,k2)(G,H).

With the previous lemmas we can determine the relation of the logics 𝖢(k1,k2) and 𝖢(k1,k2) for any given combination of parameters.

Theorem 13.

For all k1,k2 and k1,k2 with k1+k2,k1+k22 it holds that 𝖢(k1,k2)𝖢(k1,k2) if and only if one of the following assertions holds:

  1. 1.

    k1<k1 and k1+k2k1+k2,

  2. 2.

    k1k1 and k1+k2<k1+k2, or

  3. 3.

    k1=1, k1=0, and k2>2k2.

Furthermore, it holds that 𝖢(k1,k2)𝖢(k1,k2) if and only if (k1,k2)=(k1,k2).

This settles the question of how the use of non-requantifiable variables affects the expressive power of the logic. For the investigation of the logic 𝖢(k1,k2) for fixed parameters, it is also of interest how the non-requantifiable variables behave in concrete formulas of the logic. This relates closely to asking whether there are normal forms for the logic 𝖢(k1,k2) with respect to reusability. We give a precise answer to this question that rules out many such normal forms. The idea is to construct a new family of base graphs that allow the use of non-reusable cops only after all reusable cops have been used a certain number of times.

Definition 14.

We construct the graph G˙h× from the grid graph Gh× by adding one additional vertex b, which we call bridge vertex, and the edges {{vi,2,b}:i[h]}{{b,vi,2+1}:i[h]} to Gh×. Using this modified grid, we define the following base graph:

For 2,h1 and d1 we obtain the graph Bh×d by replacing every vertex of a perfect binary tree Bd of depth d by a grid G˙h× and connect adjacent grids row-wise (see Figure 1).

Theorem 15.

For all k1,k21 and r1 there exist graphs G and H such that (S) has a winning strategy for BP(k1,k2)(G,H) and in every winning strategy (S) must reuse every reusable pebble pair at least r times (once if k1=1) before using a new non-reusable pebble pair.

Proof.

For k1>1, we consider the game CR(k1,k2)(B(k11)×2rk2+1), see Figure 1. The cops have the following winning strategy: First, they build a barrier in the root grid (behind the bridge vertex) by occupying one full column using k1 reusable cops. The barrier can then be moved towards the robber using the additional reusable cop. When the barrier reaches the last column, the two subtrees induced by the children of the root grid are disconnected components with respect to the cops. Thus, the robber has to choose an edge in one of these components to escape to. The cops move the barrier into the corresponding subtree, which essentially results in the game CR(k1,k2)(B(k11)×2rk2). In every grid of the tree, the cops encounter a bridge vertex that can be covered by one of the k2 non-reusable cops. The game continues inductively for Ω(rk2) rounds, until the cops use the last remaining non-reusable cop to cover the bridge vertex in a leaf grid. The barrier can be moved to the end of the grid and the robber will be caught. Now assume a new non-reusable cop y has been used before all reusable cops have been (re)used r times at some point of the game. Then the barrier was not moved out of the current grid at this point, since all reusable cops have to be moved at least r times to achieve this. Hence, the robber has not chosen a new subtree so far and can pick an edge in a subtree that does not contain y. The cops need to move the barrier into that subtree and use non-reusable cops for the bridge vertices. Since y was used in another subtree, at some point there will be no non-reusable cops left to cover a bridge vertex and the barrier cannot be moved further without breaking down. Thus, the robber can escape indefinitely. For k1=1 we consider the game CR(1,k2)(B2k2). The cops have the following winning strategy: First, the reusable cop x1 is placed in the root node. This disconnects the subtrees induced by the two children of the root node for the robber, and the robber has to choose an edge in one of the subtrees of depth 2k21. Accordingly, a non-reusable cop y1 is placed on the node inducing that subtree, which again disconnects two subtrees of depth 2k22. The cop x1 can be picked up again from the root node to be placed on the corresponding subtree. Inductively, the cops alternately use non-reusable cops yj and the reusable cop x1 to cover the next child node. After 2k2 moves, the induced subtree is of depth 0 and the robber is caught in the edge to a leaf node. If two non-reusable cops are used consecutively, similar to the case k1>1, there are no non-reusable cops left at depth 2k21 and the remaining reusable cop does not suffice to catch the robber.

Figure 1: A drawing of the base graph B3×43 for Theorem 15.

Again using Theorem 6 this result translates into the language of logic as follows:

Corollary 16.

For all k1,k21 and r1 there exist graphs G,H such that G and H are not 𝖢(k1,k2)-equivalent and for every formula φ𝖢(k1,k2) that distinguishes G and H the following holds: There exists a sequence of subformulas n1yj1ψ1,,nk2yjk2ψk2 of φ such that qr(ψk2)=k1 and for [k21] the formula ψ+1 is a subformula of ψ with qr(ψ)qr(ψ+1)+k1r if k1>1 and qr(ψ)qr(ψ+1)+1 if k1=1. Moreover, between the quantifications nyjψ and n+1yj+1ψ+1 all requantifiable variables have to be requantified r times (once if k1=1) in ψ.

The necessity of this pattern of (re)quantification rules out various normal forms with respect to requantification for 𝖢(k1,k2) one might have hoped to have. In particular, it is not sufficient to quantify all non-requantifiable variables directly one after the other.

Regarding classical logics without restricted requantification, Theorem 13 and Corollary 16 yield that for k1,k21 the power of 𝖢(k1,k2) to distinguish graphs is not identical to that of 𝖢k,𝖢r, or 𝖢rk for all k,r.

5 Space Complexity

In this section we investigate the space complexity of deciding whether two given graphs are 𝖢(k1,k2)-equivalent. In principle, this can be achieved by testing owl(k1,k2)()(G)=owl(k1,k2)()(H) by Theorem 6. However, a naive implementation of (k1,k2)-OWL requires space Ω(nk1+k2) and hence provides no improvement compared to the situation with unrestricted reusability. We seek to improve the space complexity to O(nk1logn) when both requantifiable and non-requantifiable variables are involved. Here the O notation hides factors depending on k1 and k2 but not on n.

To achieve this, we observe that the color owl(k1,k2)(r)(G,α¯) only depends on the colors owl(k1,k2)(s)(G,β¯) with s<r where β|[yk2] is an extension of α|[yk2]. This allows us to compute these colorings, while only ever remembering colors of assignments with a few distinct [yk2]-parts. Moreover, we show that the (k1,k2)-dimensional oblivious Weisfeiler-Leman algorithm can equivalently be implemented by alternatingly refining with respect to the reusable dimensions until the coloring stabilizes, and refining with respect to the first unassigned non-requantifiable variable. We use this to show that the iteration number of (k1,k2)-OWL is at most (k2+1)nk11.

Definition 17.

For colorings χ and χ on a set S, we say that χ refines χ, written χχ, if every χ-color class is a union of χ-color classes. If χχ and χχ, we write χχ.

In the context of colorings, it is natural to understand the oblivious Weisfeiler-Leman algorithm as a refinement operator, i.e., a function that maps every coloring to a refined coloring. To make this formal, we define for every coloring χ on assignments α:[xk1,yk2]V(G) the OWL-refinement

owlref(k1,k2)(χ)(α)(χ(α), {{χ(α[xi/w]):wV(G)}}i[k1],
{{χ(α[yj/w]):wV(G)}}jJ(α)).

This refinement is precisely the refinement that is applied by OWL in each iteration. In particular, applying it r times to the initial coloring by atomic types yields precisely the r-round OWL-coloring. That is,

owlref(k1,k2)(r)(atpk1+k2(G))=owl(k1,k2)(r)(G).

Note that OWL-refinement is monotone in the sense that for all colorings χ and χ with the property χχ it also holds that owlref(k1,k2)(χ)owlref(k1,k2)(χ).

In order to space-efficiently deal with these refinements, we want to separate the refinements with respect to reusable dimensions from those with respect to non-reusable dimensions. To do this, note that the definition of owlref(k1,k2) still makes sense for colorings assignments α:[xk1,yk2]V(G) for k1k1 or k2k2, where the refinement just refines with respect to some but not all of the dimensions.

Moreover, in order to handle the distinguishing power of (k1,k2)-OWL on two different graphs, we note that we can also simultaneously apply these refinement operators to colorings on assignments over two different graphs.

With this terminology at hand, we can clarify the intuition we may gain from Section 4 regarding the employment of non-reusability. That is, in order to distinguish graphs, it suffices to alternatingly refine with respect to all requantifiable variables and a non-requantifiable variable.

Lemma 18.

For all k1+k21, we have

owl(k1,k2)()(G)(owlref(k1,0)()owlref(0,k2))(k2)(owl(k1,0)()(G))

Proof.

Because owl(k1,k2) is a finer refinement than owlref(k1,0) and than owlref(0,k2), the direction is immediate. For the other direction, set

χr(owlref(k1,0)()owlref(0,k2))(r)(owl(k1,0)()(G)).

We use the bijective pebble game and show, by induction on r, that for every (k1,k2)-configuration (α,β) over G with |dom(α)[yk2]|=k2r such that α and β have equal χr-colors, (D) has a winning strategy in the game BP(k1,k2)(G,G) with initial position (α,β). This then implies the equality of owlref(k1,k2)()(χ)-colors.

For r=0, the colors are precisely the colors computed by (k1,k2)-OWL. Thus, (D) has a winning strategy by Theorem 6.

Now, assume the claim is true for some r and let (α,β) be a (k1,k2)-configuration with |dom(α)[yk2]|=k2(r+1) such that α and β have equal χr+1-colors. By the construction of (k1,0)-OWL refinement, (D) can preserve the equality of χr+1-colors as long as (S) picks up reusable pebble pairs. When (S) picks up a non-reusable pebble pair, (D) can play such that the resulting positions have the same χr-colors. But then, (D) has a winning strategy by the induction hypothesis.

Because classical owl(k1,0)-refinement stabilizes after at most nk11 rounds, this scheme yields an upper bound on the iteration number of the oblivious Weisfeiler-Leman algorithm.

Corollary 19.

The sequence of colorings owl(k1,k2)(r) computed on a graph G stabilizes after at most (k2+1)nk11 rounds.

We will now turn to the computation of the OWL-colorings. Because the names of the OWL-colors consist of nested multisets, they can become exponentially long. The usual way to deal with this is to either replace after each iteration round all color names by numbers of logarithmic length, or to not compute the colors at all but only consider the order on the variable assignments induced by the lexicographic ordering of their OWL-colors. We will switch between these two viewpoints depending on suitability to the task at hand. Accordingly, we use two different encodings of the colorings we deal with. Consider a coloring χ:MC and an order on the set of colors C. We say that an algorithm is given oracle access to the ordering of χ-colors if the algorithm has access to a function that, given two elements m,mM, returns whether χ(m)χ(m). For the second way that our algorithms interact with colorings, we call a coloring χ:M[|M|] a normalization of χ if for all m,mM we have χ(m)χ(m) if and only if χ(m)χ(m). Now, we say that an algorithm is given a function table for χ if for some normalization χ of χ the algorithm is given an array A with A[m]=χ(m) for all mM suitably encoded as numbers in [|M|]. Similarly, we say that an algorithm computes a function table for χ if it outputs such an array. Note that a function table can be stored in space |M|log2|M|O(|M|log|M|).

The main technical tool needed for the implementation of owlref(k1,k2)-refinements, is the ability to compare multisets of previously computed colors when given oracle access to a function comparing these previous colors.

Lemma 20.

Given a natural number n in unary, oracle access to a total order on [n], and two multisets M and M on [n] of order at most n, the lexicographic order of M and M can be decided in logarithmic space using quadratic time. Also, the lexicographical order of tuples of colors can be computed in logarithmic space.

Proof.

Consider two multisets M={{s1,,sn}} and M={{s1,,sn}}. Note that we have enough space to store a constant number of elements of [n].

For a number i[n], we denote the number of occurrences of i in M or M by M(i) and M(i) respectively. Note that these numbers can be computed in logarithmic space and linear time by simply comparing i to all elements in either set.

We start by finding the minimal element m1 of M and m1 of M. If m1m1, we return their order. Otherwise, if M(m1)M(m1), we return this order.

Thus, assume m1=m1 and that they occur in both multisets the same number of times. Next, we find the second-smallest elements m2 and m2 of both sets, and can now forget about m1 and m1. We again compare m2 and m2 and their number of occurrences and possibly return the order accordingly. Iteratively, we only need to remember the i-th smallest elements to find the (i+1)-th smallest elements, and we iteratively compare these elements and their number of occurrences.

This allows us to compute the order of owlref(k1,k2)(χ)-colors in logarithmic space when we are given oracle access to the order of χ-colors. Using the bound on the iteration number of (k1,k2)-OWL from Corollary 19, and the fact that we can perform one iteration using only logarithmic additional space, we immediately obtain an algorithm that can compare owl(k1,k2)()-colors using space at most O(nk1logn), where we again dropped multiplicative factors depending on k1 and k2. However, this naive implementation will not run in polynomial time. Indeed, because there are already nk1+k2 many variable assignments, we do not have enough space to store even the (order of) colors computed in the previous round. Instead, this naive algorithm recomputes polynomially many previous colors in every step, which leads to a polynomially branching algorithm with exponential running time.

To remedy this, we make full use of the scheme from Lemma 18. While performing owl(k1,0)-refinements, we are able to store a function table with the previously computed colors for all assignments with the same [yk2]-part. This allows us to perform a full owl(k1,0)()-refinement in polynomial time and the required space. Only when performing one of the k2 many owl(0,k2)-refinement steps do we need to consider variable assignments with different [yk2]-parts. In this latter case, we cannot circumvent needing to compute colors for these assignments polynomially many times. While this does again lead to a polynomially branching algorithm, the depth of this branching is bounded by k2, which leads to a polynomial running time increase of nk2.

For a fixed assignment η:[yk2]V(G), we denote by [[xk1,yk2]V(G)]η the set of assignments α:[xk1,yk2]V(G) whose [yk2]-part is η. Because we only ever need to compare the colors of two assignments at a time, it will always be sufficient to compute the OWL-coloring on sets of the form

[[xk1,yk2]V(G)]ηG˙[[xk1,yk2]V(H)]ηH

for a (0,k2)-configuration (ηG,ηH) over G and H. When restricting ourselves to assignments in such a set, the coloring computed by (k1,0)-OWL can be computed as usual:

Lemma 21.

Let k1+k21, G,H be graphs and (ηG,ηH) be a (0,k2)-configuration over G,H. Given a function table for a coloring χ on [[xk1,yk2]V(G)]ηG˙[[xk1,yk2]V(H)]ηH, a function table for owlref(k1,0)(χ) can be computed in time nO(k1) and space O(k1nk1logn).

Proof.

Note that |[[xk1,yk2]V(G)]ηG˙[[xk1,yk2]V(H)]ηH|=2(n+1)k1, which means that we can store a function tables for χ and owlref(k1,0)(χ) in space

O(2(n+1)k1log(2(n+1)k1))=O(k1nk1logn).

In addition to these two function tables, we will only need logarithmic space.

In order to compute the function table for owlref(k1,0)(χ), we need to refine the coloring χ with respect to the multisets

{{χ(α[xi/w]):wV(G)}}or{{χ(α[xi/w]):wV(H)}}

for all i[k1]. By using the function table for χ as an oracle, we can compare these multisets in logarithmic additional space using Lemma 20.

This allows us to compare owlref(k1,0)(χ)-colors in the required space. Now, we simply start to compare each variable assignment α with all other assignments and count the number of assignments whose color is less than or equal to α. Then, we use this count as the new color of α and insert it into our function table.

By applying Lemma 21 repeatedly until the coloring stabilizes, and only ever storing the function table from the previous and current iteration round we get the following:

Corollary 22.

Let k1+k21, G and H be graphs, and (ηG,ηH) be a (0,k2)-configuration over G and H. Given a function table for a coloring χ on [[xk1,yk2]V(G)]ηG˙[[xk1,yk2]V(H)]ηH, a function table for owlref(k1,0)()(χ) can be computed in time nO(k1) space O(k1nk1logn).

Now, we turn to refinements with respect to non-requantifiable variables.

Lemma 23.

Let k1+k21, G and H be graphs, and χ a coloring on [[xk1,yk2]V(G)]˙[[xk1,yk2]V(H)].

Given oracle access to the order of χ-colors, we can compute for every (0,k2)-configuration (ηG,ηH) the function table of owlref(0,k2)(χ) on [[xk1,yk2]V(G)]ηG˙[[xk1,yk2]V(H)]ηH using space O(k1nk1logn+k2logn) and time nO(k1).

Proof.

Note that we have enough space to hold the function table. In addition, we will only need logarithmic space.

Using Lemma 20, we can compute the lexicographic ordering of owlref(0,k2)(χ)-colors with logarithmic additional space. We can then compute the function table by assigning to each assignment α as the new color the number of assignments β in [[xk1,yk2]V(G)]ηG˙[[xk1,yk2]V(H)]ηH such that

owlref(0,k2)(χ)(β)lexowlref(0,k2)(χ)(α),

which is a number in [2(n+1)k1].

Together, these two statements allow us to compare the colors computed by the (k1,k2)-dimensional oblivious Weisfeiler-Leman algorithm in a time- and space-efficient manner.

Theorem 24.

Let k1+k21 be fixed. For all (k1,k2)-configurations (α,β) over graphs G and H, we can decide whether G,α1𝖢(k1,k2)H,α2 using space O(k1(k2+1)nk1logn+(k2)2logn) and polynomial time.

Proof.

By Lemma 18, we have

owl(k1,k2)()(G)(owlref(k1,0)()owlref(0,k2))(k2)(owl(k1,0)()(G)).

and similarly for H. We show by induction on r that we can compute for every pair of graphs G1,G2{G,H} and every (0,k2)-configuration (η1,η2) over G1 and G2, a function table of

χr(owlref(k1,0)()owlref(0,k2))(r)(owl(k1,0)())

on [[xk1,yk2]V(G1)]|η1˙[[xk1,yk2]V(G2)]|η2 using time nO((k1+1)(r+1)) and space O(k1(r+1)nk1logn+k2(r+1)logn), where owl(k1,0)()(G1,G2) is the common coloring computed by (k1,k2)-OWL on both G1 and G2.

If r=0, we only need to compute the classical OWL-coloring. To do this, we first note that we can compute a function table listing the atomic types of assignments, each encoded as numbers in [2(n+1)k1]. Then, the claim follows from Corollary 22.

For the induction step, assume we can compute function tables for (restrictions of) the coloring χr for every fixed (0,k2)-configuration (η1,η2) over G1 and G2 in the required time and space. This in particular implies that we can compute the order of χr-colors of arbitrary assignments in time nO((k1+1)(r+1)) and space O((r+1)(k1nk1logn+k2logn)).

For every fixed (0,k2)-configuration (η1,η2), we can thus compute a function table for the refined coloring owlref(0,k2)(χr) on [[xk1,yk2]V(G)]η1,η2 using space O((r+2)(k1nk1logn+k2logn)) by Lemma 23. Because the algorithm from Lemma 23 runs in time nO(k1), it can make at most nO(k1) comparisons of previously computed colors, which means that this step takes time at most nO(k1)nO((k1+1)r)=nO((k1+1)(r+2)).

Using Corollary 22, we can refine this to a function table of

χr+1=owlref(k1,0)()owlref(0,k2)(χr)

For r=k2, this yields the claim.

6 Graphs Identified by Logics with Restricted Requantification

We finally give two classes of graphs where very few reusable variables already suffice for identification. We say that a logic identifies a graph G if it distinguishes G from every non-isomorphic graph.

First, we show that the logic 𝖢(0,d+1) identifies all graphs of tree-depth at most d. Second, we refine previous work in which it was shown that 𝖢(4,0) identifies all planar graphs [28]. By closely inspecting the arguments, we show that already 𝖢(2,2) suffices to identify all 3-connected planar graphs.

Graphs of bounded tree-depth

Tree-depth is a graph parameter that intuitively measures how close a graph is to a star [32]. Let G be a graph and let G1,,Gp be the connected components of G. Then the tree-depth of G is inductively defined as

td(G){1if |G|=11+minvV(G)td(Gv)if p=1 and |G|>1maxi[p]td(Gi)otherwise.

Note that a graph has tree-depth 1 if and only if it is an independent set, and tree-depth 2 if and only if it is a disjoint union of isolated vertices and stars. Intuitively, graphs of bounded tree-depth are those which, by repeatedly deleting one vertex in each connected component, can be eliminated in a bounded number of rounds. We start by showing how to simulate this deletion of vertices by pebbling them instead.

Definition 25.

Let G be a graph with vertex coloring χG and let vV(G). We define the colored graph Gv as the graph Gv with the new coloring χGv defined by setting

χGv(w){(χG(w),1)if {v,w}E(G)(χG(w),0)if {v,w}E(G)

for all wV(G){v}.

Lemma 26 ([16, Lemma 4.5]).

Let k22, G,H be graphs with |G|=|H|2 and vV(G),wV(H) with χG(v)=χH(w). Then the following are equivalent:

  1. 1.

    (D) has a winning strategy for BP(0,k2)(G,H) with initial position given by α(y1)=v,β(y1)=w and dom(α)=dom(β)={y1}.

  2. 2.

    (D) has a winning strategy for BP(0,k21)(Gv,Hw).

We can now prove our result on identification of graphs of bounded tree-depth:

Theorem 27.

For all d1, the logic 𝖢(0,d+1) identifies all colored graphs of tree-depth at most d.

Proof.

For two graphs G and C, denote by noc(G,C) the number of connected components of G that are isomorphic to C. Using the equivalence of the logic and bijective pebble game, it suffices to prove the following claim, which lends itself better to an inductive proof:

Claim 28.

Let G and H be colored graphs, and C a connected, colored graph of tree-depth at most k2. If noc(G,C)noc(H,C), then (S) has a winning strategy for the game BP(0,k2+1)(G,H).

Proof.

We argue by induction on k2. If k2=1, then C is a single vertex. Thus, G and H differ in the number of isolated vertices of some specific color, which allows (S) to win in 2 rounds.

For the induction step, assume that the claim is true for k2. Now, consider a graph C with td(C)k2+1 and assume w.l.o.g. that noc(G,C)>noc(H,C). By the definition of tree-depth, C contains a vertex c such that td(Cc)k2. Let s be the number of such vertices.

We call a vertex v in either G or H C-shrinking if it is contained in a connected component Cv isomorphic to C, and td(Cvv)k2. The number of C-shrinking vertices in G and H is snoc(G,C) and snoc(H,C) respectively. In particular, G contains more C-shrinking vertices than H.

Now, we describe the winning strategy for (S) in the game BP(0,k2+2)(G,H). First, (S) picks up the (unused) pebble pair y1, and (D) picks a bijection f:V(G)V(H). Then there exist some C-shrinking vertex vV(G) such that its image f(v) is not C-shrinking in H. Then (S) places the pebble pair on these two vertices. By Lemma 26, it now suffices to argue that (D) has a winning strategy for the game BP(0,k2+1)(Gv,Hf(v)). For this, let Cv be the connected component of v in G, and consider the connected components Cv(1),,Cv()of CvvGv. If for some i[], we have noc(Gv,Cv(i))noc(Hf(v),Cv(i)), then we are done by the induction hypothesis. Thus, we are left with the case that noc(Gv,Cv(i))=noc(Hf(v),Cv(i)). Note that the vertex-colorings of Gv and Hf(v) ensure that all connected components isomorphic to Cv(i) for some i are incident to v or f(v) respectively. Thus, all copies of Cv(i) in G lie in Cv.

In this case, there is an isomorphism φ between the subgraphs induced by Gv and Hf(v) on the union of connected components isomorphic to Cv(i) for some i[]. The vertex-colorings of Gv and Hf(v) further ensure that φ can be extended by φ(v)f(v), so that its domain is all of Cv. Thus, φ now embeds Cv into the connected component of f(v), which might, however, have additional vertices attached to f(v). If the image of Cv under φ was the whole connected component of f(v), then f(v) would be C-shrinking, which contradicts our assumption. Thus, there are additional vertices attached to f(v). Thus, v and f(v) have distinct degrees, which allows (S) to win in one further round. The theorem now follows by applying the claim to all connected components of G. Note that using Theorem 24 on the space complexity of 𝖢(k1,k2)-equivalence, the theorem in particular reproves the statement that isomorphism of graphs of bounded tree-depth can be decided in logarithmic space [5].

Note moreover that because 𝖢(1,1) can count the number of connected components isomorphic to a fixed colored star, the above inductive proof also shows that for d2, the logic 𝖢(1,d1) identifies all colored graphs of tree-depth at most d.

3-connected planar graphs

The next class of graphs we consider are 3-connected planar graphs. These naturally appear in the proof that 𝖢4 identifies all planar graphs, which starts by reducing the claim for arbitrary planar graphs to 3-connected planar graphs via the decomposition into triconnected components [28]. We recall their proof that 𝖢4 identifies every 3-connected planar graph and show that it actually already yields that 𝖢(2,2) suffices.

The underlying technical lemma is the following:

Lemma 29 ([28, Lemma 23]).

Let G be a 3-connected planar graph and let v1,v2,v3V(G). If v1,v2,v3 lie on a common face of G, then wl1()(G(v1,v2,v3)) is a discrete coloring.

In the classical setting, from this lemma one can obtain that 4-WL, i.e., 𝖢5 identifies all 3-connected planar graphs. We make use of our framework and show that instead it suffices to use non-reusable resources to cover the individualized vertices.

Corollary 30 (compare [28, Corollary 24]).

The logic 𝖢(2,3) identifies all 3-connected planar graphs.

Proof.

Let G be a 3-connected planar graph. By Lemma 29, there are v1,v2,v3V(G) such that wl1()(G(v1,v2,v3)) is a discrete coloring. Then by Lemma 1, also owl(2,0)()(G(v1,v2,v3)) is a discrete coloring, which implies that G(v1,v2,v3) is identified by 𝖢(2,0). Thus, there exists a formula φ(y1,y2,y3)𝖢(2,3) which defines the graph G with three individualized vertices represented by y1,y2 and y3 up to isomorphism. But then, the formula y1y2y3φ(y1,y2,y3) identifies G.

In order to improve the identification result from 𝖢5 to 𝖢4 and from 𝖢(2,3) to 𝖢(2,2), one observes that for almost all 3-connected graphs, the individualization of just 2 vertices already suffices for the above claim, and the exceptions, where indeed, 3 vertices are necessary are somewhat rare.

Definition 31.

A 3-connected planar graph is called an exception if there are no two vertices v1,v2V(G) such that wl1()(G(v1,v2)) is discrete.

The crucial tool in lowering the number of variables needed is an explicit classification of all exceptions [28]. This allows to prove the following:

Lemma 32.

All exceptions are identified by 𝖢(2,2).

Proof.

The exceptions are the following:

  • all bipyramids, i.e., cycles with two additional non-adjacent but otherwise universal vertices,

  • all platonic solids besides the dodecahedron, and the rhombic dodecahedron,

  • the triakis tetrahedron, the tetrakis hexahedron and the triakis octahedron, i.e., the graphs obtained from the tetrahedron, the hexahedron and the octahedron by adding one vertex per face, whose neighborhood consists of the vertices on that face.

Because even color refinement identifies every graph with at most 5 vertices, and the bipyramid of order 6 is the octahedron, we start with bipyramids of order at least 7. We individualize two adjacent vertices of the cycle. Then, color refinement computes a discrete coloring on the underlying cycle, while the two pyramid tips get the same color, which is, however, distinct from all other colors. This graph is identified by color refinement.

Next, consider the platonic solids and the rhombic dodecahedron. All of these are distance-regular graphs of diameter at most 4, with at most 14 vertices. Note that for every d, there exists a formula φd(y1,y2)𝖢(2,2) stating that y1 and y2 have distance d. This implies that in 𝖢(2,2) we can express that a graph G is distance-regular with a given parameter set. Because every distance-regular graph of order at most 14 is determined by its parameters [38], 𝖢(2,2) identifies all platonic solids and the rhombic dodecahedron.

For the last case, note that the vertices of the platonic solid and the added vertices for every face have distinct degrees. As moreover, adding these vertices does not change the distance between any two original vertices, 𝖢(2,2) can still express that the underlying platonic solid is of the correct type. Additionally, we can express that the neighborhood of each added face vertex is a cycle of the correct length, and that no two face vertices share more than 2 common neighbors. This identifies the last class of exceptions.

This finally allows us to prove identification by 𝖢(2,2):

Theorem 33.

Every 3-connected planar graph is identified by 𝖢(2,2).

Proof.

Let G be a 3-connected planar graph. If G is an exception, this follows from Lemma 32. If G is not an exception, the claim can be proven as in Corollary 30, where we instead only need to individualize 2 instead of 3 vertices.

It is unclear how precisely this result generalizes to all planar graphs. Moreover, it is known that all graphs of Euler genus g are identified by 𝖢4g+4 [18], and we would expect that also here, for sufficiently connected graphs only a very small number of the variables must be requantified.

7 Outlook

In this work, we establish a refined framework for the logical description of graphs by means of the requantification of variables. We indicate some open questions for future work in vastly different directions.

Towards structural graph theory, the newly defined cops-and-robber game CR(k1,k2) defines a two-parametric family of graph classes, which contain the tree-width and tree-depth graphs as subclasses. It will be interesting to obtain graph-theoretic characterizations for these classes and to study them from an algorithmic and logical point of view.

From a practical viewpoint, the space complexity is generally the roadblock to a use of higher-dimensional Weisfeiler-Leman in isomorphism testing and graph neural networks. The introduction of non-requantifiable variables is a technique to limit space complexity, so it needs to be investigated whether problems that arise in practice can be solved by this technique.

In another direction, it will be interesting to investigate other classes of graphs that are known to have bounded Weisfeiler-Leman dimension. Using the new variant with restricted reusability, it may be possible to obtain a more fine-grained complexity measure and more space-efficient algorithms for such graph classes. In particular, it seems highly plausible that (sufficiently connected) bounded genus graphs require only a limited number of requantifiable variables. This might allow to design easier fixed-parameter tractable results for graph isomorphism, for example on bounded genus graphs (see [18]). However, for this there are further restrictions, as non-reusable variables must be choosable from FPT-size bounded sets.

References

  • [1] Pablo Barceló, Floris Geerts, Juan L. Reutter, and Maksimilian Ryschkov. Graph neural networks with local graph parameters. In Advances in Neural Information Processing Systems 34: Annual Conference on Neural Information Processing Systems 2021, NeurIPS 2021, December 6-14, 2021, virtual, pages 25280–25293, 2021. URL: https://proceedings.neurips.cc/paper/2021/hash/d4d8d1ac7e00e9105775a6b660dd3cbb-Abstract.html.
  • [2] Beatrice Bevilacqua, Fabrizio Frasca, Derek Lim, Balasubramaniam Srinivasan, Chen Cai, Gopinath Balamurugan, Michael M. Bronstein, and Haggai Maron. Equivariant subgraph aggregation networks. In The Tenth International Conference on Learning Representations, ICLR 2022, Virtual Event, April 25-29, 2022. OpenReview.net, 2022. URL: https://openreview.net/forum?id=dFbKQaRk15w.
  • [3] Jin-yi Cai, Martin Fürer, and Neil Immerman. An optimal lower bound on the number of variables for graph identification. Comb., 12(4):389–410, 1992. doi:10.1007/BF01305232.
  • [4] Jinzhuan Cai, Jin Guo, Alexander L. Gavrilyuk, and Ilia Ponomarenko. A large family of strongly regular graphs with small Weisfeiler-Leman dimension. arXiv:2312.00460 [math.CO], 2023. arXiv. doi:10.48550/arXiv.2312.00460.
  • [5] Bireswar Das, Murali Krishna Enduri, and I. Vinod Reddy. Logspace and FPT algorithms for graph isomorphism for subclasses of bounded tree-width graphs. In M. Sohel Rahman and Etsuji Tomita, editors, WALCOM: Algorithms and Computation - 9th International Workshop, WALCOM 2015, Dhaka, Bangladesh, February 26-28, 2015. Proceedings, volume 8973 of Lecture Notes in Computer Science, pages 329–334. Springer, 2015. doi:10.1007/978-3-319-15612-5_30.
  • [6] Samir Datta, Nutan Limaye, Prajakta Nimbhorkar, Thomas Thierauf, and Fabian Wagner. Planar graph isomorphism is in log-space. ACM Trans. Comput. Theory, 14(2):8:1–8:33, 2022. doi:10.1145/3543686.
  • [7] Anuj Dawar and David Richerby. The power of counting logics on restricted classes of finite structures. In Jacques Duparc and Thomas A. Henzinger, editors, Computer Science Logic, pages 84–98, Berlin, Heidelberg, 2007. Springer Berlin Heidelberg. doi:10.1007/978-3-540-74915-8_10.
  • [8] Holger Dell, Martin Grohe, and Gaurav Rattan. Lovász meets Weisfeiler and Leman. In Ioannis Chatzigiannakis, Christos Kaklamanis, Dániel Marx, and Donald Sannella, editors, 45th International Colloquium on Automata, Languages, and Programming, ICALP 2018, July 9-13, 2018, Prague, Czech Republic, volume 107 of LIPIcs, pages 40:1–40:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2018. doi:10.4230/LIPICS.ICALP.2018.40.
  • [9] Zdenek Dvorák. On recognizing graphs by numbers of homomorphisms. J. Graph Theory, 64(4):330–342, 2010. doi:10.1002/JGT.20461.
  • [10] Michael Elberfeld and Ken-ichi Kawarabayashi. Embedding and canonizing graphs of bounded genus in logspace. In Symposium on Theory of Computing, STOC 2014, New York, NY, USA, May 31 - June 03, 2014, pages 383–392. ACM, 2014. doi:10.1145/2591796.2591865.
  • [11] Michael Elberfeld and Pascal Schweitzer. Canonizing graphs of bounded tree width in logspace. ACM Trans. Comput. Theory, 9(3):12:1–12:29, 2017. doi:10.1145/3132720.
  • [12] Eva Fluck, Tim Seppelt, and Gian Luca Spitzer. Going deep and going wide: Counting logic and homomorphism indistinguishability over graphs of bounded treedepth and treewidth. In Aniello Murano and Alexandra Silva, editors, 32nd EACSL Annual Conference on Computer Science Logic, CSL 2024, February 19-23, 2024, Naples, Italy, volume 288 of LIPIcs, pages 27:1–27:17. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPICS.CSL.2024.27.
  • [13] Martin Fürer. Weisfeiler-Lehman refinement requires at least a linear number of iterations. In Fernando Orejas, Paul G. Spirakis, and Jan van Leeuwen, editors, Automata, Languages and Programming, 28th International Colloquium, ICALP 2001, Crete, Greece, July 8-12, 2001, Proceedings, volume 2076 of Lecture Notes in Computer Science, pages 322–333. Springer, 2001. doi:10.1007/3-540-48224-5_27.
  • [14] Martin Grohe. Fixed-point definability and polynomial time on graphs with excluded minors. J. ACM, 59(5):27:1–27:64, 2012. doi:10.1145/2371656.2371662.
  • [15] Martin Grohe. Descriptive Complexity, Canonisation, and Definable Graph Structure Theory, volume 47 of Lecture Notes in Logic. Cambridge University Press, 2017. doi:10.1017/9781139028868.
  • [16] Martin Grohe. Counting bounded tree depth homomorphisms. In Holger Hermanns, Lijun Zhang, Naoki Kobayashi, and Dale Miller, editors, LICS ’20: 35th Annual ACM/IEEE Symposium on Logic in Computer Science, Saarbrücken, Germany, July 8-11, 2020, pages 507–520. ACM, 2020. doi:10.1145/3373718.3394739.
  • [17] Martin Grohe. The logic of graph neural networks. In 36th Annual ACM/IEEE Symposium on Logic in Computer Science, LICS 2021, Rome, Italy, June 29 - July 2, 2021, pages 1–17. IEEE, 2021. doi:10.1109/LICS52264.2021.9470677.
  • [18] Martin Grohe and Sandra Kiefer. A linear upper bound on the Weisfeiler-Leman dimension of graphs of bounded genus. In Christel Baier, Ioannis Chatzigiannakis, Paola Flocchini, and Stefano Leonardi, editors, 46th International Colloquium on Automata, Languages, and Programming, ICALP 2019, July 9-12, 2019, Patras, Greece, volume 132 of LIPIcs, pages 117:1–117:15. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2019. doi:10.4230/LIPICS.ICALP.2019.117.
  • [19] Martin Grohe, Moritz Lichter, Daniel Neuen, and Pascal Schweitzer. Compressing CFI graphs and lower bounds for the Weisfeiler-Leman refinements. In 64th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2023, Santa Cruz, CA, USA, November 6-9, 2023, pages 798–809. IEEE, 2023. doi:10.1109/FOCS57990.2023.00052.
  • [20] Martin Grohe and Daniel Neuen. Canonisation and definability for graphs of bounded rank width. ACM Trans. Comput. Log., 24(1):6:1–6:31, 2023. doi:10.1145/3568025.
  • [21] Jin Guo, Alexander L. Gavrilyuk, and Ilia Ponomarenko. On the Weisfeiler-Leman dimension of permutation graphs. arXiv:2305.15861 [math.CO], May 2023. arXiv. URL: https://arxiv.org/abs/2305.15861, doi:10.48550/arXiv.2305.15861.
  • [22] Lauri Hella. Logical hierarchies in PTIME. Inf. Comput., 129(1):1–19, 1996. doi:10.1006/INCO.1996.0070.
  • [23] Jelle Hellings, Marc Gyssens, Jan Van den Bussche, and Dirk Van Gucht. Expressive completeness of two-variable first-order logic with counting for first-order logic queries on rooted unranked trees. In Proceedings of the 38th Annual ACM/IEEE Symposium on Logic in Computer Science (LICS), pages 1–13, 2023. doi:10.1109/LICS56636.2023.10175828.
  • [24] Neil Immerman. Relational queries computable in polynomial time. Inf. Control., 68(1-3):86–104, 1986. doi:10.1016/S0019-9958(86)80029-8.
  • [25] Neil Immerman. Descriptive complexity. Graduate texts in computer science. Springer, 1999. doi:10.1007/978-1-4612-0539-5.
  • [26] Neil Immerman and Eric Lander. Describing graphs: A first-order approach to graph canonization. Complexity Theory Retrospective, pages 59–81, 1990. doi:10.1007/978-1-4612-4478-3_5.
  • [27] Sandra Kiefer. The Weisfeiler-Leman algorithm: an exploration of its power. ACM SIGLOG News, 7(3):5–27, 2020. doi:10.1145/3436980.3436982.
  • [28] Sandra Kiefer, Ilia Ponomarenko, and Pascal Schweitzer. The Weisfeiler-Leman dimension of planar graphs is at most 3. J. ACM, 66(6):44:1–44:31, 2019. doi:10.1145/3333003.
  • [29] Haiyan Li, Ilia Ponomarenko, and Peter Zeman. On the Weisfeiler-Leman dimension of some polyhedral graphs. arXiv:2305.17302 [math.CO], May 2023. arXiv. doi:10.48550/arXiv.2305.17302.
  • [30] Steven Lindell. A logspace algorithm for tree canonization (extended abstract). In S. Rao Kosaraju, Mike Fellows, Avi Wigderson, and John A. Ellis, editors, Proceedings of the 24th Annual ACM Symposium on Theory of Computing, May 4-6, 1992, Victoria, British Columbia, Canada, pages 400–404. ACM, 1992. doi:10.1145/129712.129750.
  • [31] Christopher Morris, Gaurav Rattan, and Petra Mutzel. Weisfeiler and Leman go sparse: Towards scalable higher-order graph embeddings. In Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020. URL: https://proceedings.neurips.cc/paper/2020/hash/f81dee42585b3814de199b2e88757f5c-Abstract.html.
  • [32] Jaroslav Nesetril and Patrice Ossona de Mendez. Tree-depth, subgraph coloring and homomorphism bounds. Eur. J. Comb., 27(6):1022–1041, 2006. doi:10.1016/J.EJC.2005.01.010.
  • [33] Martin Otto. Bounded Variable Logics and Counting: A Study in Finite Models, volume 9 of Lecture Notes in Logic. Cambridge University Press, 2017. doi:10.1017/9781316716878.
  • [34] Oleg Pikhurko and Oleg Verbitsky. Logical complexity of graphs: A survey. In Martin Grohe and Johann A. Makowsky, editors, Model Theoretic Methods in Finite Combinatorics - AMS-ASL Joint Special Session, Washington, DC, USA, January 5-8, 2009, volume 558 of Contemporary Mathematics, pages 129–180. American Mathematical Society, 2009.
  • [35] Jamie Tucker-Foltz. Inapproximability of unique games in fixed-point logic with counting. In 36th Annual ACM/IEEE Symposium on Logic in Computer Science, LICS 2021, Rome, Italy, June 29 - July 2, 2021, pages 1–13. IEEE, 2021. doi:10.1109/LICS52264.2021.9470706.
  • [36] Steffen van Bergerem. Learning concepts definable in first-order logic with counting. In 34th Annual ACM/IEEE Symposium on Logic in Computer Science, LICS 2019, Vancouver, BC, Canada, June 24-27, 2019, pages 1–13. IEEE, 2019. doi:10.1109/LICS.2019.8785811.
  • [37] Steffen van Bergerem. Descriptive complexity of learning. PhD thesis, RWTH Aachen University, Germany, 2023. URL: https://publications.rwth-aachen.de/record/953243, doi:10.18154/RWTH-2023-02554.
  • [38] E. R. van Dam, J. H. Koolen, and H. Tanaka. Distance-regular graphs. Electronic Journal of Combinatorics, 1(DynamicSurveys), 2018. doi:10.37236/4925.
  • [39] Moshe Y. Vardi. The complexity of relational query languages (extended abstract). In Proceedings of the 14th Annual ACM Symposium on Theory of Computing, May 5-7, 1982, San Francisco, California, USA, pages 137–146. ACM, 1982. doi:10.1145/800070.802186.
  • [40] Qing Wang, Dillon Ze Chen, Asiri Wijesinghe, Shouheng Li, and Muhammad Farhan. 𝒩-WL: A new hierarchy of expressivity for graph neural networks. In The Eleventh International Conference on Learning Representations, ICLR 2023, Kigali, Rwanda, May 1-5, 2023. OpenReview.net, 2023. URL: https://openreview.net/pdf?id=5cAI0qXxyv.