Improved Exact Algorithm for Finding a Maximum Exploratory Equivalent Partition

Abstract

An exploratory equivalent partition (EE partition) of a graph G with nontrivial automorphisms is a partition of its vertex set that can be directly translated into a set of constraints to speed up the search for occurrences of G in an arbitrary host graph. The maximum EE partition problem is to find an EE partition leading to the greatest speedup. However, this problem is NP-hard and the naïve algorithm is only practicable for small symmetry-rich graphs. In this paper, we propose a series of improvements based on computational group theory that vastly increase the algorithm’s range of practicability. For example, the improved algorithm spends less time on the 10-hypercube graph (1024 vertices, 5120 edges, ≈3.7 × 10⁹ automorphisms) than the naïve algorithm does on the 4-hypercube graph (16 vertices, 32 edges, 384 automorphisms). We prove that all improvements maintain the algorithm’s correctness and confirm their contribution to the speed of execution through extensive experimentation.

1. Introduction

In the era of networks of all possible types and sizes, the graph is one of the most important mathematical and computational structures. A fundamental problem associated with graphs is that of subgraph isomorphism search: given a (smaller) pattern graph G and a (larger) host graph H, report one (or all, depending on the definition) of the occurrences of G in H. This problem has found applications in computer science [1], social sciences [2], chemistry [3], logistics [4], etc.

Unfortunately, the subgraph isomorphism problem is NP-hard, implying that an efficient (polynomial-time) algorithm is unlikely to exist. In practice, some approaches do perform reasonably well for most graphs of moderate size, but may falter when the pattern graph has many symmetries (automorphisms) [5,6]. For this reason, we [7,8] defined an equivalence relation on graph vertices called exploratory equivalence. Exploratory equivalence induces an exploratory equivalent partition (or EE partition) of the graph vertex set, which can be readily translated into a set of constraints that can be employed during the execution of any subgraph isomorphism search algorithm. Those constraints may significantly improve performance; in particular, if they are applied to an algorithm that is oblivious to the symmetries of the pattern graph, they reduce the number of established vertex-to-vertex correspondences between the pattern graph and the host graph by the product of the factorials of the sizes of the equivalence classes constituting the partition. This product is called the score of the EE partition.

A given graph may have multiple EE partitions, each with its own score. Of particular interest is an EE partition with the greatest score—a maximum EE partition. (Since there may be multiple maximum EE partitions, we speak of a rather than the maximum EE partition.) Such a partition can be converted into a set of constraints that improves the performance of subgraph isomorphism search by the greatest factor.

Unsurprisingly, the problem of finding a maximum EE partition (MaxEE) is itself hard [8]. In particular, we showed that the associated verification problem (given a graph and a partition, verify that the partition is an EE partition of that graph) is at least as hard as the graph isomorphism problem and at most as hard as the set stabilizer problem, which places the verification problem between the complexity classes P and NP. This means that the decision version of the optimization problem (given a graph and an integer k, determine whether there is an EE partition with a score greater than k) is not known to be in NP, and the optimization problem itself (given a graph, report one of its maximum EE partitions) is not known to be in FNP (Function NP). In other words, it is at least as hard as the hardest problems in FNP (such as the subgraph isomorphism problem) but may, in fact, be strictly harder.

Facing the inherent hardness of the MaxEE problem, there are a few possible directions as to where to steer our research. One possibility is to focus on restricted classes of graphs, such as trees, cycles, or complete graphs. It turns out that, for some classes, the MaxEE problem can be solved in polynomial time, or it may even have a closed-form solution [9]. Another option is to seek an efficient heuristic approach. We proposed an efficient (although theoretically still superpolynomial) suboptimal algorithm and showed that it finds an optimal solution for a majority of graphs, although in some cases, the score of the discovered EE partition could arbitrarily diverge from the maximum [8].

In this paper, we take a third route. We present a novel algorithm that finds a maximum EE partition for an arbitrary graph in a highly efficient manner. Naturally, we could not escape exponential behavior for some classes of graphs, but we were nevertheless able to improve the performance significantly; for example, the time spent by the naïve algorithm (one that follows the definition of a maximum EE partition) on the 4-hypercube graph (16 vertices, 32 edges, and 384 automorphisms) is longer than the time spent by the improved algorithm on the 10-hypercube graph (1024 vertices, 5120 edges, and ≈3.7 × 10⁹ automorphisms).

The contribution of this paper is thus of a practical rather than theoretical nature. In particular, while the worst-case complexity of the algorithm remains exponential in terms of the input graph size, our experiments showed a considerable improvement of its execution time on several symmetry-rich graph families. In the process of devising an improved algorithm, we heavily relied on results from computational group theory, a standard mathematical tool for modeling symmetries.

The rest of this paper is structured as follows. Section 2 presents an overview of related work. In Section 3, we define exploratory equivalence, together with all the necessary prerequisite concepts. Section 4 describes the improved algorithm for computing exploratory equivalence. In Section 5, we experimentally validate the algorithm. Section 6 concludes the paper.

2. Related Work

As we mentioned in the introduction, the main focus of this paper is the development of a viable algorithm for the exact computation of a maximum EE partition of a given graph. Exploratory equivalence itself was defined and put into a broader context in our previous paper [8]. Here, we shall only give a brief review of related work that was not yet published at that time.

The concept of exploratory equivalence is closely related to both the graph isomorphism problem and the subgraph isomorphism problem. While the decision version of the latter problem (given a pattern graph G and a host graph H, determine whether a copy of G occurs as a subgraph of H) is NP-complete, the decision version of the former (determine whether two given graphs are isomorphic) is a member of the so-called NP-intermediate complexity class, since it belongs to NP but has not been proven to be either polynomially solvable or NP-complete.

In a breakthrough paper, Babai [10] showed that graph isomorphism can be solved in quasipolynomial time (specifically, $e^{{log}^{O\left(1\right)}n}$). While no algorithm to date has broken this barrier for general graphs, some researchers found improvements for restricted classes of graphs. For example, Grohe et al. lowered Babai’s bound for graphs with a bounded maximum degree [11] and for graphs with a bounded treewidth [12]. Lokshtanov et al. [13] proved that graph isomorphism is fixed-parameter tractable (FPT) when parameterized by treewidth (i.e., polynomial in terms of the number of vertices but exponential in terms of treewidth). A survey of methods dealing with the parameterized complexity of the graph isomorphism problem has been provided by Neuen [14].

In contrast to graph isomorphism, research on subgraph isomorphism is predominantly concerned with scalability and practicability as opposed to theoretical bounds. The main reason is that the subgraph isomorphism problem has strongly exponential complexity [15,16], which means that it cannot be solved in time $2^{o\left(n\right)}$. Recent approaches employ various strategies, such as advanced search tree pruning techniques [17], adaptive vertex ordering techniques [5], efficient representations and calculations of vertex neighborhoods [18], and parallel computation [19]. Some approaches pose subgraph isomorphism search as a constraint satisfaction problem [20]. With recent advances in machine learning and artificial intelligence, it is no wonder that these techniques have found their way into the domain of subgraph isomorphism problem as well [21].

As we shall see later, we draw on computational group theory [22,23] to develop a more efficient approach for finding a maximum EE partition. Concepts and algorithms from computational group theory have also been employed directly in (sub)graph isomorphism search algorithms to deal with symmetry; for example, Babai’s aforementioned graph isomorphism method [10] heavily relies on the Schreier–Sims algorithm [24] to represent and manipulate automorphisms.

3. Exploratory Equivalence

Before we are able to define exploratory equivalence, let us review some fundamental terms from graph theory. The 6-cycle graph (denoted $C_6$), shown in Figure 1, will serve as the running example.

Figure 1. The 6-cycle graph ($C_6$).

A graph $G=(V_G,E_G)$ (or simply $(V,E)$, if the associated graph is immaterial or clear from context) is composed of a set of vertices ($V=\{1,2,\dots ,n\}$) and a set of edges ($E\subseteq V\times V$). In this paper, we only deal with simple ($(v,v)\notin E$) undirected ($(u,v)\in E\iff (v,u)\in E$) graphs.

A monomorphism from a graph G to a graph H is an injective vertex-to-vertex mapping $h:V_G\to V_H$ that preserves adjacencies: $(u,v)\in E_G\iff (h\left(u\right),h\left(v\right))\in E_H$. If a monomorphism is also surjective, it is called an isomorphism. Graphs G and H are isomorphic if there is an isomorphism from G to H (and an isomorphism from H to G, by virtue of bijectivity). Informally, if G and H are isomorphic, one can obtain H from G merely by renumbering the vertices of G. A monomorphism from a graph G to a graph H is thus an isomorphism from G to a subgraph of H that is isomorphic to G. For this reason, a monomorphism is also called a subgraph isomorphism.

An automorphism is an isomorphism of a graph onto itself. Table 1 lists all 12 automorphisms of the 6-cycle graph. The automorphisms are presented in the usual product-of-cycles notation. For example, the automorphism $\left(153\right)\left(264\right)$ maps vertex 1 to vertex 5, 5 to 3, and 3 to 1 (the first cycle), as well as 2 to 6, 6 to 4, and 4 to 2 (the second cycle). The notation $\left(\right)$ represents the identity automorphism, which maps each vertex to itself.

Table 1. The automorphisms of the graph $C_6$.

Automorphism	Product-of-Cycles Representation
$h_1$	$\left(\right)$
$h_2$	$\left(153\right)\left(264\right)$
$h_3$	$\left(135\right)\left(246\right)$
$h_4$	$\left(165432\right)$
$h_5$	$\left(14\right)\left(25\right)\left(36\right)$
$h_6$	$\left(123456\right)$
$h_7$	$\left(26\right)\left(35\right)$
$h_8$	$\left(15\right)\left(24\right)$
$h_9$	$\left(13\right)\left(46\right)$
$h_{10}$	$\left(16\right)\left(25\right)\left(34\right)$
$h_{11}$	$\left(14\right)\left(23\right)\left(56\right)$
$h_{12}$	$\left(12\right)\left(36\right)\left(45\right)$

For any graph G, the composition of automorphisms f and g, the function $h=fg$ with $h\left(v\right)=f\left(g\right(v\left)\right)$, is itself an automorphism of G. Considering the existence of the identity automorphism and the fact that every automorphism has a unique inverse, the set of automorphisms of a graph (denoted $\mathrm{Aut}\left(G\right)$) forms a group under composition.

We shall now turn our attention to the definitions that will bring us to exploratory equivalence.

Definition 1 (cover). 

For a given graph G, a set of automorphisms $A\subseteq \mathrm{Aut}\left(G\right)$ covers a set of vertices $P=\{v_1,\dots ,v_k\}\subseteq V$ (denoted cover $(A,P)$) if for each permutation σ of P (with $\sigma \left(v_j\right)=v_{i_j}$ for $j\in \{1,\dots ,k\}$) there is an automorphism $h\in A$ such that $h\left(v_j\right)=v_{i_j}$ for each $j\in \{1,\dots ,k\}$.

The set of automorphisms of the 6-cycle graph covers the set of vertices $\{1,4\}$, since there is an automorphism with the property $h\left(1\right)=1$ and $h\left(4\right)=4$ (e.g., $h_1$) and an automorphism with the property $h\left(1\right)=4$ and $h\left(4\right)=1$ (e.g., $h_5$). We also have $\mathrm{cover}(\mathrm{Aut}\left(C_6\right),\{1,3,5\})$, since, for each permutation $(u,v,w)$ of $\{1,3,5\}$, there is an automorphism that maps 1 to u, 3 to v, and 5 to w. Indeed, $h_1$ maps the triple $(1,3,5)$ to $(1,3,5)$, $h_7$ maps it to $(1,5,3)$, $h_9$ to $(3,1,5)$, $h_3$ to $(3,5,1)$, $h_2$ to $(5,1,3)$, and $h_8$ maps the triple to $(5,3,1)$.

Definition 2 (pointwise stabilizer). 

The pointwise stabilizer of a set of automorphisms $A\subseteq$ Aut $\left(G\right)$ with respect to a set of vertices $P=\{v_1,\dots ,v_k\}\subseteq V$ (denoted PointStab $(A,P)$) is a set of automorphisms $A^{\prime }\subseteq A$ that fix all vertices in P: $h\in A$ belongs to $A^{\prime }$ if and only if $h\left(v_i\right)=v_i$ for all $i\in \{1,\dots ,k\}$.

For example, $\mathrm{PointStab}(\mathrm{Aut}\left(C_6\right),\{1,4\})=\{h_1,h_7\}$, whereas $\mathrm{PointStab}(\mathrm{Aut}\left(C_6\right)$, $\{1,3,5\})=\left\{h_1\right\}$.

The next definition is not directly required for exploratory equivalence, but it is closely related to the preceding one and will be used later in the text.

Definition 3 (setwise stabilizer). 

The setwise stabilizer of a set of automorphisms $A\subseteq$ Aut $\left(G\right)$ with respect to a set of vertices $P=\{v_1,\dots ,v_k\}\subseteq V$ (denoted SetStab $(A,P)$) is a set of automorphisms $A^{\prime }\subseteq A$ that map P to itself: $h\in A$ belongs to $A^{\prime }$ if and only if $h\left(v_i\right)\in P$ for all $i\in \{1,\dots ,k\}$.

For example, $\mathrm{SetStab}(\mathrm{Aut}\left(C_6\right),\{1,4\})=\{h_1,h_5,h_7,h_{11}\}$, whereas $\mathrm{SetStab}(\mathrm{Aut}\left(C_6\right)$, $\{1,3,5\})=\{h_1,h_2,h_3,h_7,h_8,h_9\}$. Note that both the pointwise stabilizer and the setwise stabilizer are groups themselves.

Definition 4 (ordered EE partition). 

An ordered exploratory equivalent partition of a graph $G=(V,E)$ is a sequence $(P_1,P_2,\dots ,P_s)$ such that (1) ${\bigcup }_{i=1}^s{P}_i=V$, (2) $P_i\cap P_j=\varnothing$ whenever $i\ne j$, and (3) for each $i\in \{1,\dots ,s\}$, we have cover $(A_{i-1},P_i)$ and $A_i=$ PointStab $(A_{i-1},P_i)$, where $A_0=$ Aut $\left(G\right)$.

For example, the sequence $\left(\right\{1,4\},\{2,6\},\{3\},\{5\left\}\right)$ is an ordered EE partition of the 6-cycle graph. We have already seen that $\mathrm{Aut}\left(C_6\right)$ covers $\{1,4\}$. The pointwise stabilizer of $\mathrm{Aut}\left(C_6\right)$ with respect to the set $\{1,4\}$ is the set $\{h_1,h_7\}$, which can be easily verified to cover the set $\{2,6\}$. Subsequently, $\mathrm{PointStab}(\{h_1,h_7\},\{2,6\})$ is $\left\{h_1\right\}$, which covers any singleton set and is unaffected by the pointwise stabilization with respect to a singleton set.

The graph $C_6$ has several more ordered EE partitions. One of them is $\left(\right\{1,3,5\},\{2\},\{4\}$, $\left\{6\right\})$.

Definition 5 (EE partition). 

A set $\{P_1,P_2,\dots ,P_s\}$ is an exploratory equivalent partition of a graph G if there exists a permutation σ of $\{1,2,\dots ,s\}$ such that $(P_{\sigma \left(1\right)},P_{\sigma \left(2\right)},\dots ,P_{\sigma \left(s\right)})$ is an ordered EE partition.

To simplify the notation, let $\{v_1^1,\dots ,v_{k_1}^1\mid v_1^2,\dots ,v_{k_1}^2\mid \dots \mid v_1^s,\dots ,v_{k_s}^s\mid \}$ represent an EE partition composed of the equivalence classes $P_i=\{v_1^i,\dots ,v_{k_i}^i\}$ for $i\in \{1,\dots ,s\}$, with the singletons omitted. Therefore, the EE partition $\left\{\right\{1,4\},\{2,6\},\{3\},\{5\left\}\right\}$ of $C_6$ will be written as $\{1,4\mid 2,6\mid \}$, and the EE partition $\left\{\right\{1,3,5\},\{2\},\{4\},\{6\left\}\right\}$ will be represented as $\{1,3,5\mid \}$. The same notation will be adopted for ordered EE partitions, except that the braces will be replaced by parentheses.

We shall now establish a connection between exploratory equivalence and subgraph isomorphism search.

Theorem 1. 

Let $\{P_1,P_2,\dots ,P_s\}$ with $P_i=\{v_1^i,\dots ,v_{k_i}^i\}$ be an EE partition of a graph G, and let H be a graph isomorphic to G. Then, the total number of isomorphisms h from G to H is $|P_1|!|P_2|!\dots |P_s|!r$ for some integer $r\ge 1$, and at most r of those isomorphisms have the property $h\left(v_1^i\right)<\dots <h\left(v_{k_i}^i\right)$ for all $i\in \{1,\dots ,s\}$.

Proof. 

Let A be the automorphism group of G. We first observe that the number of isomorphisms from G to H is equal to the number of automorphisms of G because G and H are isomorphic. Let us examine the subgroups $A_i\le \mathrm{Aut}\left(G\right)$ from the construction of the EE partition $P=\{P_1,P_2,\dots ,P_s\}$. For each i, let $B_i$ be the smallest subgroup of $A_{i-1}$ such that $\mathrm{cover}(B_i,P_i)$ holds. We shall denote the group of all permutations of a set X as $\mathrm{Sym}\left(X\right)$. Each $b\in B_i$ must be of the form $b=\pi \varphi$, where $\pi \in \mathrm{Sym}\left(P_i\right)$ and $\varphi \in \mathrm{Sym}(V\setminus P_i))$. In other words, $\pi$ is a permutation of the elements of $P_i$ that does not move any other elements of V, and $\varphi$ is a permutation of V that does not move any element of $P_i$. Now let us define a homomorphism f from $B_i$ to $\mathrm{Sym}\left(P_i\right)$ that maps every $b=\pi \varphi \in B_i$ to $\pi \in \mathrm{Sym}\left(P_i\right)$. This is obviously a homomorphism, and, thus, the first isomorphism theorem tells us that $B_i/ker\left(f\right)\cong \mathrm{Sym}\left(P_i\right)$. This implies that ${\displaystyle \frac{|B_i|}{|ker(f\left)\right|}}=|\mathrm{Sym}\left(P_i\right)|=|P_i|!$, so $|P_i|!$ divides $|B_i|$.

Because of the way in which EE partitions are constructed (a pointwise stabilization of $|P_i|$ in every step), we may freely permute the elements of each $P_i\in P$ independently of any other $P_j\in P$ using elements of $\mathrm{Aut}\left(G\right)$, so the groups $B_i$ must therefore be disjoint, and $B_1·B_2·\dots ·B_s$ is a subgroup of $\mathrm{Aut}\left(G\right)$. Due to Lagrange’s theorem, $|B_1|·|B_2|·\dots ·|B_s|$ divides $\left|\mathrm{Aut}\right(G\left)\right|$ and, since each $|B_i|$ is divisible by $|P_i|!$, $|P_1|!·|P_2|!·\dots ·|P_s|!$ divides $\left|\mathrm{Aut}\right(G\left)\right|$ as well. As such, $\left|\mathrm{Aut}\left(G\right)\right|=|P_1|!·|P_2|!·\dots ·|P_s|!·r$ for some $r\in \mathbb{N}$. Furthermore, imposing the restriction $h\left(v_1^i\right)<\dots <h\left(v_{k_i}^i\right)$ on all automorphisms forbids any automorphism that non-trivially permutes the elements of $P_i$. This results in the reduction of the order of $B_i$ by a factor of at least $|P_i|!$ and thus forces the order of $\mathrm{Aut}\left(G\right)$ to become no greater than r.    □

Theorem 1 can be read as follows: during the search for an isomorphism from a graph G to a graph H, one can safely restrict the search to those isomorphisms h that satisfy the requirements $v_1^i<\dots <v_{k_i}^i$ for $i\in \{1,\dots ,s\}$, without fear of ‘missing’ the fact that the graphs are isomorphic. The number of such isomorphisms is no larger than the number of all isomorphisms divided by $|P_1|!|P_2|!\dots |P_s|!$.

Since a monomorphism from a pattern graph G to a host graph H is merely an isomorphism between G and one of its occurrences in H, this observation can be immediately applied to subgraph isomorphism search. If $\{P_1,P_2,\dots ,P_s\}$ with $P_i=\{v_1^i,\dots ,v_{k_i}^i\}$ is an EE partition of the pattern graph G, we can, during the search for subgraphs of H isomorphic to G, enforce the restrictions $v_1^i<\dots <v_{k_1}^i$ for $i\in \{1,\dots ,s\}$ without missing any of the subgraphs. Furthermore, these constraints will reduce the number of discovered monomorphisms by a factor of $|P_1|!|P_2|!\dots |P_s|!$.

For example, the fact that $\{1,3,5\mid \}$ is an EE partition of the graph $C_6$ tells us that if $C_6$ is isomorphic to a graph H, only two out of 12 ($2=12/3!$) isomorphisms h from $C_6$ to H will meet the condition $h\left(1\right)<h\left(3\right)<h\left(5\right)$, regardless of how the vertices of H are numbered. A similar observation can be made for the EE partition $\{1,4\mid 2,6\mid \}$: we can impose the constraints $h\left(1\right)<h\left(4\right)$ and $h\left(2\right)<h\left(6\right)$ without missing any of the occurrences of $C_6$ in any host graph. In the Appendix A, we present two series of experiments demonstrating that EE-derived constraints may significantly reduce the amount of work performed by a subgraph isomorphism search algorithm.

The reduction factor obtained by enforcing the constraints derived from an EE partition will be called the score of the EE partition:

Definition 6 (score of an EE partition). 

The score of an EE partition $\{P_1,P_2,\dots ,P_s\}$ is $|P_1|!|P_2|!\dots |P_s|!$.

Naturally, for a given graph, we strive to find a maximum EE partition (i.e., an EE partition with the greatest score), since the corresponding constraints will lead to the greatest workload reduction when employed in (sub)graph isomorphism search. Unfortunately, as shown in [8], the problem of finding a maximum EE partition is unlikely to have a polynomial-time solution, since it is not even known whether it belongs to the class NP. Nevertheless, in the subsequent sections, we will devise an algorithm that performs reasonably well even for graphs with a large number of automorphisms.

4. The Algorithm

In this section, we describe the proposed algorithm for finding a maximum EE partition for a given input graph. We begin with the baseline (naïve) algorithm and then turn our attention to individual improvements. At the end of this section, we give the pseudocode of the final algorithm.

Before we begin, let us mention that all concepts related to an EE partition of a graph G are defined with respect to a subgroup A of the automorphism group $\mathrm{Aut}\left(G\right)$ or, alternatively, with respect to the ‘non-stabilized’ subset of the vertex set V. For example, one of the ordered EE partitions of the 6-cycle graph is $(1,4\mid 2,6)$. Once we choose the set $\{1,4\}$ as the first equivalence class and pointwise-stabilize the automorphism group with respect to the set $\{1,4\}$, we are left with the vertices $\{2,3,5,6\}$ and the set of automorphisms $\{h_1,h_7\}$ in Table 1. Now, one of the ordered EE partitions with respect to this new set of automorphisms (or, alternatively, with respect to the vertex set $\{2,3,5,6\}$) is $(2,6\mid )$.

For convenience, we shall define the following two terms:

Definition 7 (EE set). 

An EE set is a set of vertices that is part of at least one EE partition.

In other words, P is an EE set with respect to an automorphism group A if $\mathrm{cover}(A,P)$. For example, the EE sets of the graph $C_6$ are all singletons (trivially), all sets of two distinct vertices, and the sets $\{1,3,5\}$ and $\{2,4,6\}$.

Definition 8 (non-extensible EE set). 

An EE set is non-extensible if none of its supersets is an EE set.

4.1. Representation of the Automorphism Group

The algorithm starts by computing the automorphism group for the given input graph. This group is represented by a concise set of automorphisms $g_1$, …, $g_r$ called generators. The generators act as the ‘seeds’ of the automorphism group, since every automorphism can be obtained by composing one or more generators. Our algorithm works with the set of generators throughout its execution; this set is never ‘expanded’ into the full set of automorphisms. A group generated by the generators $g_1$, …, $g_r$ will be denoted $⟨g_1,\dots ,g_r⟩$.

The generators of the automorphism group of the 6-cycle graph are the automorphisms $h_6$ and $h_7$ in Table 1. All 12 automorphisms can be derived from these two generators; for instance, $h_1=h_6{h}_6{h}_6{h}_6{h}_6{h}_6=h_6^6$ and $h_8=h_6^2{h}_7$.

A well-known term in algebraic graph theory is the orbit of a vertex v in an automorphism group A, denoted ${\mathrm{Orbit}}_A\left(v\right)$. This is the set of all vertices that can be obtained by applying an arbitrary sequence of generators of A to the vertex v. Formally,

$${\mathrm{Orbit}}_A\left(v\right)=\{(g_{i_1}{g}_{i_2}\dots g_{i_k})\left(v\right)\mid k\ge 0\mathrm{and}1\le i_j\le r\mathrm{for}\mathrm{all}j\in \{1,\dots ,k\}\}.$$

Let us now extend the concept to sets of vertices:

Definition 9 (orbit of a set). 

The orbit of a set $U\subseteq V$ is the set $\{{\mathrm{Orbit}}_A\left(u\right)\mid u\in U\}$.

Table 2 gives the orbits of various EE sets of the graph $C_6$.

Table 2. The orbits of selected EE sets of the graph $C_6$.

EE Set P	$\mathbf{Orbit}\left(\mathit{P}\right)$
$\{1,2\}$	$\left\{\right\{1,2\},\{2,3\},\{3,4\},\{4,5\},\{5,6\},\{6,1\left\}\right\}$
$\{1,3\}$	$\left\{\right\{1,3\},\{2,4\},\{3,5\},\{4,6\},\{5,1\},\{6,2\left\}\right\}$
$\{1,4\}$	$\left\{\right\{1,4\},\{2,5\},\{3,6\left\}\right\}$
$\{1,3,5\}$	$\left\{\right\{1,3,5\},\{2,4,6\left\}\right\}$

4.2. Computing Cover and PointStab

Both the pointwise stabilizer and the setwise stabilizer of an automorphism group with respect to a set of vertices can be computed using the Schreier–Sims algorithm [24]. However, while the pointwise stabilizer can be computed in polynomial time with respect to the size of the graph, the setwise stabilizer problem is GI-complete, which means that it is currently not known whether a polynomial-time algorithm exists at all.

Before we see how to compute the cover predicate, let us introduce some additional terms. The symmetric group of a set $P\subseteq V$ (denoted $\mathrm{Sym}\left(P\right)$) is composed of all permutations of that set; e.g., $\mathrm{Sym}\left(\right\{1,3,5\left\}\right)=\left\{\right()$, $\left(35\right)$, $\left(13\right)$, $\left(135\right)$, $\left(153\right)$, $\left(15\right)\}$. Every automorphism group on a set P is thus a subgroup of $\mathrm{Sym}\left(P\right)$.

Given a set P, a set $P^{\prime }\subseteq P$, and an automorphism g on P such that $g\left(x\right)\in P^{\prime }$ for each $x\in P^{\prime }$, let ${g|}_{P^{\prime }}$ be an automorphism on $P^{\prime }$ such that $g^{\prime }\left(x\right)=g\left(x\right)$ for each $x\in P^{\prime }$. For example, if $g=\left(35\right)\left(26\right)$ (one of the automorphisms of $C_6$), then $g_{\{1,3,5\}}=\left(35\right)$, whereas $g_{\{1,2,3\}}$ is undefined, since g does not map the set $\{1,2,3\}$ to itself. For a set $P^{\prime }\subseteq P$ and an automorphism group A on P, let

$${A|}_{P^{\prime }}=\{g^{\prime }\mid g^{\prime }{=g|}_{P^{\prime }}\mathrm{for}\mathrm{some}g\in A\}.$$

(1)

For instance, if A is the automorphism group of $C_6$, as given by Table 1, then ${A|}_{\{1,3,5\}}=\{\left(\right)$, $\left(135\right)$, $\left(153\right)$, $\left(15\right)$, $\left(13\right)$, $\left(35\right)\}$ and ${A|}_{\{1,2,3\}}=\{\left(\right)$, $\left(13\right)\}$.

Let us now write down the lemma that will serve as the recipe for computing the cover predicate:

Lemma 1. 

Let A be an automorphism group of a graph over a set $P\subseteq V$, and let $P^{\prime }\subseteq P$. Then, we have cover $(A,P^{\prime })$ if and only if SetStab $(A,P^{\prime }){|}_{P^{\prime }}=$ Sym $\left(P^{\prime }\right)$.

Proof. 

If $\mathrm{cover}(A,P^{\prime })$, then for each automorphism g on $P^{\prime }$ (i.e., for each $g\in \mathrm{Sym}\left(P^{\prime }\right)$), there is an automorphism $h\in A$ such that $g\left(x\right)=h\left(x\right)$ for each $x\in P^{\prime }$. By definition, any such h is a member of $\mathrm{SetStab}(A,P^{\prime })$. Since each automorphism $g\in \mathrm{Sym}\left(P^{\prime }\right)$ is simply its corresponding automorphism $h\in \mathrm{SetStab}(A,P^{\prime })$ restricted to $P^{\prime }$ (${g=h|}_{P^{\prime }}$), the set of automorphisms g is a subset of the set of automorphisms h restricted to $P^{\prime }$; i.e., $\mathrm{Sym}\left(P^{\prime }\right)\subseteq \mathrm{SetStab}(A,P^{\prime }){|}_{P^{\prime }}$. Since $\mathrm{Sym}\left(P^{\prime }\right)$ is a supergroup of any permutation group over $P^{\prime }$, we conclude that $\mathrm{Sym}\left(P^{\prime }\right)=\mathrm{SetStab}(A,P^{\prime }){|}_{P^{\prime }}$.

Conversely, if $\mathrm{SetStab}(A,P^{\prime }){|}_{P^{\prime }}=\mathrm{Sym}\left(P^{\prime }\right)$, then for each $g\in \mathrm{Sym}\left(P^{\prime }\right)$, there is an automorphism $h\in \mathrm{SetStab}(A,P^{\prime })$ such that $h\left(x\right)=g\left(x\right)$ for each $x\in P^{\prime }$. This is precisely the definition of $\mathrm{cover}(A,P^{\prime })$.    □

Continuing our running example, we can confirm that the automorphism group A of $C_6$ covers the set $\{1,3,5\}$, since ${\mathrm{SetStab}(A,\{1,3,5\})|}_{\{1,3,5\}}=\{\left(\right)$, $\left(35\right)$, $\left(13\right)$, $\left(135\right)$, $\left(153\right)$, $\left(15\right)\}=\mathrm{Sym}(\{1,3,5\})$. However, $\mathrm{cover}(A,\{1,2,3\left\}\right)$ is false, as ${\mathrm{SetStab}(A,\{1,2,3\})|}_{\{1,2,3\}}=\{\left(\right)$, $\left(13\right)\}\ne \mathrm{Sym}(\{1,2,3\})$.

Since the generators of an automorphism group are automorphisms themselves, we can work with the generators rather than the full set of automorphisms. To obtain ${A|}_P$, we simply take the generators of A and retain exactly those cycles in each generator that permute only the elements of P. For example, the generators of the automorphism group A of $C_6$ are $\left(26\right)\left(35\right)$ and $\left(123456\right)$, and the generators of $B=\mathrm{SetStab}(A,\{1,3,5\left\}\right)$ are $g_1=\left(26\right)\left(35\right)$ and $g_2=\left(135\right)\left(246\right)$. To compute the generators of ${B|}_{\{1,3,5\}}$, we retain only the second cycle in $g_1$ and the first cycle in $g_2$, obtaining $g_1^{\prime }=\left(35\right)$ and $g_2^{\prime }=\left(135\right)$. Following that, we verify that the group generated by $g_1^{\prime }$ and $g_2^{\prime }$ is equal to $\mathrm{Sym}\left(\right\{1,3,5\left\}\right)$ (this can be achieved using a procedure described in [22]) and confirm that A covers $\{1,3,5\}$.

Since it is potentially expensive to obtain the setwise stabilizer, we would like to minimize the number of computations of the cover predicate. Most of the improvements of the baseline algorithm are concerned precisely with this challenge.

4.3. The Baseline Algorithm

The baseline algorithm for finding a maximum EE partition of a given graph is shown as Algorithm 1. It closely follows the definition of exploratory equivalence. On each invocation of the recursive function, the algorithm considers all subsets of size 2 or more of the current vertex set V (i.e., the set of those vertices that have not yet been ‘fixed’ by applying the pointwise stabilizer in the previous invocations of the function) to find out which of them are EE sets. For each EE set P, the algorithm constructs a candidate EE partition by taking the union of $\left\{P\right\}$ and the maximum EE partition obtained for the rest of the graph. The candidate EE partition with the greatest score becomes the result of the function.

Algorithm 1 The baseline algorithm for finding a maximum EE partition

As expected, this algorithm is highly inefficient. As we will see in Section 5, it spends more than half an hour on the 4-hypercube graph with mere 16 vertices, 32 edges, and 384 automorphisms on an average desktop machine. Fortunately, as we will see shortly, this naïve algorithm can be greatly improved.

4.4. Building Larger EE Sets from Smaller Ones

In general, there is no need to consider all subsets of the current vertex set when searching for EE sets. Clearly, if P is not an EE set, neither is any of its supersets. However, we can go further: it turns out that a set is not worth consideration unless all of its subsets have been determined to be EE sets.

Lemma 2. 

If a set is an EE set, all of its subsets are EE sets as well.

Proof. 

Let A be an automorphism group, let P be an EE set with respect to A, and let $P^{\prime }$ be a subset of P. It holds that $\mathrm{Sym}\left(P^{\prime }\right)\subseteq \mathrm{Sym}\left(P\right)$. Since the predicate $\mathrm{cover}(A,P)$ ensures that there exists some automorphism $a\in A$ for every permutation $g\in \mathrm{Sym}\left(P\right)$ such that $a\left(p\right)=g\left(p\right)$ for every $p\in P$, the same must hold for every permutation $g^{\prime }\in \mathrm{Sym}\left(P^{\prime }\right)$. Therefore, $\mathrm{cover}(A,P^{\prime })$ holds, and $P^{\prime }$ is an EE set with respect to A.    □

This observation suggests that the subsets of the current vertex set should be considered from smaller to larger. First, we find all 2-vertex EE sets. Having found all k-vertex EE sets, we proceed to $(k+1)$-vertex subsets of the current vertex set, but we immediately discard a set $P=\{v_1,v_2,\dots ,v_{k+1}\}$ unless all of the k-vertex sets $P\setminus \left\{v_1\right\}$, $P\setminus \left\{v_2\right\}$, …, $P\setminus \left\{v_{k+1}\right\}$ have been found to be EE sets.

In practice, as we will see later, we find sets to be considered as potential larger EE sets by voting. A k-vertex set $P\subseteq V$ with $V\setminus P=\{v_1,\dots ,v_m\}$ casts a vote for each of the sets $P\cup \left\{v_1\right\}$, …, $P\cup \left\{v_m\right\}$. Following the voting procedure, only those $(k+1)$-vertex sets that have garnered $k+1$ votes are checked to determine whether they are EE sets. Indeed, a set $Q=\{v_1,\dots ,v_{k+1}\}$ receives $k+1$ votes only if all of the sets $Q\setminus \left\{v_1\right\}$, …, $Q\setminus \left\{v_{k+1}\right\}$ vote for it. This will only happen if each of these $k+1$ sets is a k-element EE set.

Note, however, that winning $k+1$ votes is only a necessary, but not sufficient, condition for a set to be an EE set. A counterexample is provided by the graph $C_6$. Here, $\{1,2\}$, $\{1,3\}$, and $\{2,3\}$ are all 2-element EE sets, so they all cast a vote for the set $\{1,2,3\}$. This set therefore receives three votes, but it is not an EE set.

4.5. Enforcing the Lower Bound for Score During Search

Lemma 3. 

The score of an EE partition of a graph G cannot be greater than |Aut(G)|.

Proof. 

By Theorem 1, the number of automorphisms of G (i.e., $\left|\mathrm{Aut}\right(G\left)\right|$) is divisible by the score of any EE partition of G. Therefore, the score cannot be greater than $\left|\mathrm{Aut}\right(G\left)\right|$.    □

Lemma 4. 

Let $P_1$, …$P_k$ be mutually disjoint subsets of V. If $P_1$, …, $P_k$ are (some of the) equivalence classes of an EE partition $\mathcal{P}$, the score of $\mathcal{P}$ cannot be greater than $|P_1|!\dots |P_k|!|$ PointStab $(V,P_1\cup \dots \cup P_k)|$.

Proof. 

Let us assume that we are building an EE partition with respect to some group A. We shall observe the following: if we are building an EE partition $\mathcal{P}$ and have found the EE sets $P_1,P_2,\dots ,P_k$, the search for further EE sets is an independent subproblem, itself a search for an EE partition of the set $V\setminus (P_1\cup P_2\cup \dots \cup P_k)$ with respect to the automorphism group $\mathrm{PointStab}(A,P_1\cup \dots \cup P_k)$. For any EE partition ${\mathcal{P}}^{\prime }$ that we find as a solution to this subproblem, it must hold that $\mathrm{score}\left({\mathcal{P}}^{\prime }\right)\le \left|\mathrm{PointStab}(A,P_1\cup \dots \cup P_k)\right|$ because of Lemma 3. Therefore, the inequality $\mathrm{score}\left(\mathcal{P}\right)\le |P_1|!\dots |P_k|!|\mathrm{PointStab}(A,P_1\cup \dots \cup P_k)|$ must hold.    □

Lemma 4 is immediately useful in the process of finding a maximum EE partition, since the score of an already constructed EE partition (or even the score of a partial EE partition; i.e., an EE partition ‘under construction’) can be used as a lower bound for the maximum attainable score. Furthermore, once all EE sets on the current level of recursion have been found, they should be considered from the largest to the smallest, in order to set the lower bound as high as possible as early as possible.

4.6. Exploiting Symmetry in Finding EE Sets and EE Partitions

Exploratory equivalence enables us to exploit symmetry (or, to take a look from a different angle, to reduce its adverse effects) in a pattern graph when searching for its occurrences in a host graph. However, it turns out that symmetry can also be put to use when searching for exploratory equivalence itself.

Lemma 5. 

If $P\subseteq V$ is an EE set, then each of the members of Orbit $\left(P\right)$ is an EE set. If $P\subseteq V$ is not an EE set, then none of the members of Orbit $\left(P\right)$ is an EE set.

Proof. 

Assume that $P\subseteq V$ is an EE set with respect to the automorphism group A, which implies $\mathrm{cover}(A,P)$. For every $P^{\prime }\in \mathrm{Orbit}\left(P\right)$, there exists a $g\in A$ such that $g\left(P\right)=P^{\prime }$. Furthermore, since $\mathrm{cover}(A,P)$ holds, there exists an $h\in A$ for every permutation p of P such that $h\left(i\right)=p\left(i\right)$ for every $i\in P$. However, since we can define a distinct permutation of $P^{\prime }$ in A for each such h as $h^{\prime }=gh{g}^{-1}$, $\mathrm{cover}(A,P^{\prime })$ must hold as well.

Let us now assume that P is not an EE set, but $P^{\prime }\in \mathrm{Orbit}\left(P\right)$ is. Then $P\in \mathrm{Orbit}\left(P^{\prime }\right)$ is also true and, as we have shown above, this implies that P is an EE set, which is a contradiction.    □

In fact, EE sets themselves form equivalence classes, with two sets belonging to the same class if and only if they belong to the same orbit. Therefore, the right-hand column of Table 2 actually shows the equivalence classes of the EE sets of $C_6$.

The notion of equivalence of EE sets can be naturally extended to EE partitions. For each EE partition, we can construct a set of equivalent EE partitions by applying the same composition of generators to each constituent equivalence class; for example, $\{1,4\mid 2,6\mid \}$ is an EE partition of $C_6$, but so are $\{2,5\mid 3,1\mid \}$ and $\{3,6\mid 4,2\mid \}$. Let us state this fact more formally:

Lemma 6. 

Let $g_1$, …, $g_r$ be the generators of an automorphism group A, and let $g=g_{i_1}\dots g_{i_k}$ with $k\ge 0$ and $i_1$, …, $i_k\in \{1,\dots ,r\}$ be the composition of an arbitrary sequence of generators. If $\{P_1,\dots ,P_s\}$ is an EE partition, then so is $\{g\left(P_1\right),\dots ,g\left(P_s\right)\}$.

Proof. 

Let $S_i=\mathrm{PointStab}(A,P_1\cup \dots \cup P_{i-1})$. Now, let us consider the set $g{S}_i{g}^{-1}$. We observe that it must stabilize the sets $g\left(P_1\right),\dots ,g\left(P_{i-1}\right)$ since, for every $g\left(p_j\right)\in g\left(P_j\right)$ and $s_i\in S_i$, we have $g{s}_i{g}^{-1}g\left(p_j\right)=g{s}_i\left(p_j\right)=g\left(p_j\right)$. We can also see that it must cover $g\left(P_i\right)$ if $S_i$ covers $P_i$, because for any permutation $p\in S_i$ of $P_i$, there exists a distinct permutation $gp{g}^{-1}$ of $g\left(P_i\right)$. As we can see, the two conditions required for an EE partition must hold for $\{g\left(P_1\right),\dots ,g\left(P_s\right)\}$ if they hold for $\{P_1,\dots ,P_s\}$.    □

Lemma 7. 

Let $\mathcal{M}\left(P\right)$ be the set of all ordered EE partitions that start with an EE set P. For each EE set $P^{\prime }\in$ Orbit $\left(P\right)$, we have $|\mathcal{M}\left(P^{\prime }\right)|=|\mathcal{M}\left(P\right)|$. Furthermore, for each ordered EE partition $\mathcal{P}$ in $\mathcal{M}\left(P\right)$, there is an ordered partition ${\mathcal{P}}^{\prime }$ in $\mathcal{M}\left(P^{\prime }\right)$ such that $|{\mathcal{P}}^{\prime }|=|\mathcal{P}|$ and the equivalence classes of ${\mathcal{P}}^{\prime }$ have the same sizes as those of ${\mathcal{P}}^{\prime }$.

Proof. 

This result follows from Lemma 6 since, for every $\mathcal{P}\in \mathcal{M}\left(P\right)$ and $g\left(P\right)\in \mathrm{Orbit}\left(P\right)$ with $g\in \mathrm{Aut}\left(G\right)$, there exists a $g\left(\mathcal{P}\right)\in \mathcal{M}\left(g\right(P\left)\right)$, where $g\left(\mathcal{P}\right)$ is the EE partition that we obtain from $\mathcal{P}$ by applying g to all of its classes. Furthermore, the equivalence classes of $g\left(\mathcal{P}\right)$ have the same sizes as those of $\mathcal{P}$, and $\left|g\right(\mathcal{P}\left)\right|=\left|\mathcal{P}\right|$. Since $P\in \mathrm{Orbit}\left(g\right(P\left)\right)$ is true as well, this also holds in the other direction. We thus have a bijection between $\mathcal{M}\left(P\right)$ and $\mathcal{M}\left(g\right(P\left)\right)$, so $\left|\mathcal{M}\right(P\left)\right|=\left|\mathcal{M}\right(g\left(P\right)\left)\right|$.    □

Lemmas 5 and 7 effectively imply that we can restrict our attention to ‘representatives’ of the equivalence classes of EE sets, and any EE set in an equivalence class can be chosen as a representative. When building an EE partition, once we determine that P is an EE set, we can neglect all other members of $\mathrm{Orbit}\left(P\right)$, since we know that choosing P as the next equivalence class of the candidate EE partition $\mathcal{P}$ being constructed will have the same effect as choosing any other member of $\mathrm{Orbit}\left(P\right)$ for that role: the resulting candidate EE partition will have the same score as $\mathcal{P}$.

Recall that it makes no sense to check whether a k-element (with $k\ge 3$) set P is an EE set unless we have determined that all of its $(k-1)$-element subsets are EE sets. For instance, we proceed to checking whether $\{1,3,5\}$ is an EE set of $C_6$ only after we have discovered that the sets $\{1,3\}$, $\{1,5\}$, and $\{3,5\}$ are EE sets. These three sets, as evidenced by Table 2, belong to the same orbit. As it turns out, this is no coincidence:

Lemma 8. 

If P is an EE set with $k\ge 2$ elements, then all of its $(k-1)$-element subsets belong to the same orbit.

Proof. 

Let us assume that P is an EE set with respect to some automorphism group A. Let Q and R be subsets of P such that $\left|Q\right|=\left|R\right|=k-1$. By Lemma 2, the sets Q and R are also EE sets. Since $\mathrm{cover}(A,P)$ holds, we have ${\mathrm{SetStab}(A,P)|}_P=\mathrm{Sym}\left(P\right)$. One of the permutations within ${\mathrm{SetStab}(A,P)|}_P$ (say, g) has the property that $g\left(Q\right)=R$, and hence $R\in \mathrm{Orbit}\left(Q\right)$. Since Q and R have been freely chosen, this holds for all subsets of P with size $k-1$.    □

This lemma provides a further boost to our algorithm. Imagine that we have discovered that $P=\{v_1,\dots ,v_k\}$ is an EE set and would like to determine which of its supersets $P^{\prime }=P\cup \left\{v\right\}$ for $v\in V\setminus P$ are also EE sets. Without Lemma 8, we would have to consider all k-element subsets of $P^{\prime }$ in the voting procedure. However, Lemma 8 tells us that we only have to consider those k-element subsets of $P^{\prime }$ that belong to $\mathrm{Orbit}\left(P\right)$.

4.7. Two Further Improvements

We have seen that, during the search for candidate EE sets, we can downsize the number of the invocations of the costly $\mathrm{cover}(A,P)$ function by proceeding from smaller to larger sets and by taking advantage of symmetry. However, we can reduce this number even further by observing that some EE sets may be extracted directly from the generators of the automorphism group. For example, one of the two generators of $C_6$—namely, $g=$ (123456)—represents an automorphism where vertex 1 is mapped to vertex 2, vertex 2 to vertex 3, …, and vertex 6 to vertex 1. By taking g to the 3rd power, we obtain the automorphism $g^3=\left(14\right)\left(25\right)\left(36\right)$, where vertex 1 is mapped to vertex 4 and vice versa, and likewise for the pairs (2, 5) and (3, 6). Consequently, we can immediately infer that $\{1,4\}$, $\{2,5\}$, and $\{3,6\}$ are EE pairs of $C_6$. This observation can be generalized to arbitrary permutation cycles of even length:

Lemma 9. 

Let us assume that the generators of the automorphism group are represented as products of cycles. For each even-length cycle $(v_1,\dots ,v_{2k})$ in those products, the sets $\{v_1,v_{k+1}\}$, $\{v_2,v_{k+2}\}$, …, $\{v_k,v_{2k}\}$ are EE sets.

Proof. 

Let $(v_1,\dots ,v_{2k})$ be one of the cycles in the product-of-cycles representation of some generator g. Every generator is an automorphism, and so are their compositions. The automorphism g maps the vertices $v_1$, $v_2$, …, $v_{2k-1}$, $v_{2k}$ to $v_2$, $v_3$, …, $v_{2k}$, $v_1$, respectively, whereas the automorphism $g^k$ maps $v_i$ to $v_{k+i}$ (for all $i\in \{1,\dots ,k\}$) and $v_{k+i}$ to $v_i$ (for all $i\in \{1,\dots ,k\}$). Consequently, for each $i\in \{1,\dots ,k\}$, the set $\{v_i,v_{k+i}\}$ is an EE set.    □

The last improvement of the approach is purely technical: in some cases, the orbit of the same EE set P with respect to the same automorphism group would have to be computed twice: (1) when building a set of representative EE sets and (2) when searching for larger EE sets based on smaller ones. For this reason, we maintain a dictionary that maps a given EE set to its orbit with respect to the current automorphism group.

4.8. The Algorithm in Pseudocode

We are now ready to present the improved algorithm for finding a maximum EE partition. The pseudocode of the algorithm is shown in Algorithms 2–5. To provide a clearer overall picture of the algorithm, Figure 2 displays its simplified call graph, where a directed edge between two nodes indicates that the function corresponding to the source node invokes the function corresponding to the target node. The bottom part of each node presents a sample invocation of the corresponding function on a subgroup of the automorphism group of $C_6$ or an EE set of that graph. For example, the function FindEEPairs, if invoked on the automorphism group of $C_6$, returns a set consisting of EE pairs $\{1,2\}$, $\{3,5\}$, and $\{3,6\}$, which can be easily verified to be a representative set of EE pairs. (An equivalent output would be $\left\{\right\{1,2\}$, $\{1,3\}$, $\{1,4\}\}$, since $\{1,3\}\in \mathrm{Orbit}\left(\right\{3,5\left\}\right)$ and $\{1,4\}\in \mathrm{Orbit}\left(\right\{3,6\left\}\right)$.)

Algorithm 2 Finding a maximum EE partition (part 1/4)

Figure 2. A simplified call graph of the pseudocode presented in Algorithms 2–5.

Let us now turn our attention to individual functions. The function FindMaxEE, which serves as the entry point of the algorithm, and the recursive function FindMaxEERec, which is immediately invoked by FindMaxEE, are shown as Algorithm 2. The function FindMaxEERec is broadly similar to its namesake in the baseline algorithm (Algorithm 1). However, it calls a designated function FindEESets for producing a set of representative EE sets, rather than checking every subset of V to see whether it is exploratory equivalent. Another difference is that the new version maintains and uses the global lower bound for the maximum score ($s^{*}$), which can be used to discard partial EE partitions that have no chance of exceeding the current maximum. To attain a high $s^{*}$ value early in the process, we consider the discovered representative EE sets from the largest to the smallest.

Algorithm 3 Finding a maximum EE partition (part 2/4)

The function FindEESets (Algorithm 3) produces a set of representative EE sets for the given automorphism group over the given subset of the vertex set. Recall that only one EE set (although an arbitrary one) from each orbit can be declared the representative set of the orbit. The function starts with representative 2-element EE sets (called ‘EE pairs’ for simplicity) and then iteratively proceeds to larger sets. In the i-th iteration of the loop, the function discovers all representative ($i+2$)-element EE sets from the pool consisting of representative ($i+1$)-element EE sets.

The function FindEEPairs finds all representative EE pairs. By invoking the function PairsFromGenerators, it starts with the EE pairs that can be directly derived from the generators of the automorphism group. The function then finds out which of those EE pairs are representative; if two of them belong to the same orbit, at most one can be picked as the representative for that orbit. To find representative EE pairs that cannot be obtained directly from the generators, the function FindEEPairs calls the function FindRepresentativeEESets.

Algorithm 4 Finding a maximum EE partition (part 3/4)

Algorithm 5 Finding a maximum EE partition (part 4/4)

The function FindRepresentativeEESets (Algorithm 4) maintains a set $\mathcal{S}$ of the subsets of V that have already been determined to be EE sets and a set $\mathcal{T}$ of the subsets of V that have been proven to be non-EE sets. For each set P that belongs neither to $\mathcal{S}$ nor to $\mathcal{T}$, the function checks to see whether it is covered by the set of automorphisms. If it is, the entire orbit of the set P is added to the set $\mathcal{S}$; otherwise, the orbit is added to the set $\mathcal{T}$. An EE set is added to the output set $\mathcal{E}$ only if none of the sets in its orbit have been added to $\mathcal{E}$. Thereby, we ensure that exactly one EE set from each orbit is added to the set of representative EE sets.

The function FindLargerEESets (Algorithm 4) accepts a set of representative EE sets of size $k-1$ and returns a set of representative EE sets of size k. It relies on the fact that a necessary condition for a set $\{v_1,\dots ,v_k\}$ to be an EE set is that all of its ($k-1$)-element subsets are EE sets themselves (Lemma 2) and that, moreover, all of those ($k-1$)-element subsets belong to the same orbit (Lemma 8). To find the potential k-element EE sets, we proceed as follows. Starting with a ($k-1$)-element EE set P, we search its orbit for all sets Q that can be obtained from P by removing one vertex in P and adding one vertex not in P. The two ($k-1$)-element sets P and Q are both subsets of the same k-element set $R=P\cup Q$, and so both P and Q cast a vote for R. If, after the entire orbit of P has been scanned, the set R has gathered k votes, we know that all of its subsets are EE sets. Consequently, R is considered a potential EE set and is placed into a pool $\mathcal{R}$. At the end, just like the function FindEEPairs, the function FindLargerEESets calls the function FindRepresentativeEESets to find those sets in the pool $\mathcal{R}$ that are exploratory equivalent and to make sure that only one EE set remains from each orbit.

Finally, the function ComputeOrbit (Algorithm 5) computes the orbit of a given EE set with respect to the given automorphism group. The function simply maintains a set $\mathcal{O}$ of vertex sets that have already been determined to belong to the orbit of the input set. In each iteration, the function applies each generator to all vertex sets that have been added to $\mathcal{O}$ in the previous iteration (at the beginning, this is just the input vertex set) and adds the resulting vertex sets to the set $\mathcal{O}$. The loop is finished once it turns out that nothing more can be added to $\mathcal{O}$. The ensuing set $\mathcal{O}$ is the orbit of the input EE set, and it is added to the dictionary $\mathcal{D}$ to avoid its potential repeated computation.

4.9. Correctness

Theorem 2. 

For a given graph, the function FindMaxEE in Algorithm 2 reports a maximum EE partition.

Proof. 

An ordered EE partition is a sequence of EE sets. Clearly, if we consider every possible EE set for each position in the sequence, we will have considered all EE partitions by the end of the search process. By keeping track of the maximum-score EE partition constructed so far, we will ultimately arrive at a maximum EE partition.

However, by Lemma 7, we need not consider every EE set at every step (i.e., in every recursive invocation of the function FindMaxEERec), but only one EE set per orbit. As we will show later, the function FindEESets does just that. Furthermore, by Lemma 4, we can safely discard an EE partition being constructed if its maximum potential score falls short of the maximum product of the factorials of the class sizes encountered so far (the value $s^{*}$ in Algorithm 2). It is easy to see that the function FindMaxEERec updates and uses the value $s^{*}$ in such a way that at least one maximum EE partition remains.

The function FindEEPairs finds all representative 2-element EE sets for the given automorphism group. Following the code that extracts representative EE pairs directly from the generators, the basis of which is provided by Lemma 9, the function FindEEPairs calls FindRepresentativeEESets to discover representative EE pairs from the pool of remaining vertex pairs. In FindRepresentativeEESets, each pair that has been determined to be an EE set is added to the output set, provided that it is not yet a member of the set $\mathcal{S}$, which is the union of the orbits of the EE pairs found so far. In this way, we ensure that all EE pairs are considered but only representatives of the individual orbits are actually returned from the function.

The function FindLargerEESets first builds a pool of potential k-element EE sets given the set of representative $(k-1)$-element EE sets using a straightforward voting scheme and the conditions established by Lemmas 2 and 8. Following that, it extracts from the pool a set of representative k-element EE sets in much the same way as the function FindEEPairs (both functions call FindRepresentativeEESets to this end). The function FindLargerEESets thus finds all representative k-element EE sets, provided that it has been given all representative $(k-1)$-element EE sets.

We have seen that the function FindEEPairs finds all representative EE pairs, while the function FindLargerEESets finds all representative k-element EE sets from representative $(k-1)$-element EE sets. Therefore, the function FindEESets returns all representative EE sets for the given automorphism group. Considering the discussion from the first two paragraphs of this proof, we can conclude that the function FindMaxEE finds a maximum EE partition.    □

4.10. Implementation

The algorithm has been implemented in the Python programming language (version 3.10.12) coupled with the Sage framework (version 9.5; https://www.sagemath.org). To compute the pointwise stabilizer and the setwise stabilizer of an automorphism group with respect to a vertex set, we invoke the corresponding built-in Sage function. We would do the same to compute the orbit of a given vertex set were it not for the surprising fact that our own Python implementation, which follows the function ComputeOrbit in Algorithm 5, actually performs faster.

The full Python–Sage implementation is accessible at https://github.com/firsht1/ee, accessed on 21 September 2026.

4.11. Computational Complexity

Our objective was not to improve the theoretical computational complexity but to devise a viable algorithm that would perform reasonably well on a majority of symmetry-rich graphs of reasonable sizes. Nevertheless, a brief discussion on this topic will not hurt.

We will not attempt to derive a formula for computational complexity, since this is not the purpose of this paper, but it might still be useful to identify the main factors that contribute to the overall complexity:

(1)

The size of the largest EE set.

(2)

The cost of computing the cover predicate.

(3)

The cost of computing the orbit.

(4)

The cost of potential backtracking in the recursive FindMaxEERec function.

Let us first focus on factor (1). To find an EE set of size s, the algorithm has to enumerate all subsets of sizes 2, …, $s-1$, for a total of ${\sum }_{i=2}^s\left({\displaystyle \genfrac{}{}{0pt}{}{n}{i}}\right)$ subsets. If $s=n$, we arrive at a factor of $2^n$.

Regarding factors (2) and (3), recall that computing the cover predicate takes exponential time, while the orbit can be found in polynomial time [23]. It is therefore important to compute the cover predicate for as few sets as possible.

The fourth factor is hard to estimate, but by considering the candidate EE sets on each level of recursion from the largest to the smallest and by maintaining the lower bound for maximum EE score, we can hope to reduce backtracking as much as possible.

Since exploratory equivalence is closely connected to the automorphism group, an interesting question is how the size of that group (i.e., the number of automorphisms) affects the computational complexity. Surprisingly, there appears to be no direct link between these two measures; the number of automorphisms affects the running time only indirectly, through the factors given above. In particular, a larger number of automorphisms may lead to a larger number of EE sets, potentially causing a greater amount of backtracking and also influencing factors (2) and (3). Alternatively, a larger automorphism group may lead to larger EE classes and thus affect factor (1). Therefore, the effect of the number of automorphisms on the computational complexity of the improved algorithm is adequately captured by the factors (1) through (4) listed above.

As we have seen, even the improved algorithm may take exponential time with respect to the input size in the worst case. This should not surprise us, for we proved that finding a maximum EE partition is NP-hard [8]. If we actually managed to bring the worst-case time complexity down to polynomial, this would imply a major collapse of the computational complexity hierarchy or, much more likely, a serious error in our thought process.

To conclude this section, we will try to estimate the computational complexity of the improved algorithm for two specific graph families: complete graphs ($K_n$) and path graphs ($P_n$). The graph $K_n$ has n vertices and an edge between each distinct pair of vertices, while the graph $P_n$ has n vertices and an edge between vertices i and $i+1$, for all $i\in \{1,\dots ,n-1\}$.

The graph $K_n$ has the maximum possible number of automorphisms ($n!$), and its sole maximum EE partition is simply $\{1,\dots ,n\mid \}$. If run on $K_n$, the proposed algorithm for finding a maximum EE partition will start with a single 2-element set (say, $\{1,2\}$), discover that it is an EE set, and compute its orbit, which contains all 2-element subsets of the vertex set V. Following that, it will start the voting procedure and find out that each of the 3-element subsets of V has received three votes. By checking one of those sets to see if it is an EE set and computing its orbit, it will have determined that all 3-element subsets of V are EE sets. The algorithm will then proceed to 4-element subsets, etc., effectively enumerating all subsets of V in the process. This directly gives a complexity of $\mathsf{\Omega }\left(2^n\right)$, but we may be confident that it is actually $\mathsf{\Theta }\left(2^n\right)$, since (1) there is absolutely no backtracking (once the algorithm discovers the EE set $\{1,\dots ,n\}$, it has effectively finished); (2) the costly setwise stabilizer is computed only for $n-1$ of those $2^n$ sets (for a single 2-element set, for a single 3-element set, etc.).

The $P_n$ case is quite different. For all $n\ge 2$, the graph $P_n$ has only two automorphisms, and one of its maximum EE partitions is $\{1,n\mid \}$. Naturally, $P_n$ only has EE sets of size 2: these are $\{i$, $n-i+1\}$ for $i\in \{1,\dots ,\lfloor n/2\rfloor \}$. Unfortunately, these sets do not belong to the same orbit; instead, each forms its own orbit, while the 2-element non-EE sets (these also have to be considered, since the algorithm does not ‘know’ in advance which set is an EE set) form orbits of size 2 at most. This means that the algorithm will have to compute the cover predicate for $\mathsf{\Theta }\left(n^2\right)$ subsets of V, giving a complexity that is exponentially dependent on $n^2$. However, backtracking poses no problems, since choosing any 2-element EE set as the first equivalence class will set the lower bound to $2!$ and effectively eliminate the alternatives.

5. Experimental Results and Discussion

Having presented the improved algorithm for finding a maximum exploratory equivalent partition, we proceed to its experimental validation. To provide a better insight into the effect of individual improvements, we also run the tests using an implementation of the baseline algorithm (given as Algorithm 1) and three ‘intermediate’ versions, each building upon the preceding version by including one more improvement.

This section is structured as follows. In Section 5.1, we describe the graph sets on which we tested the five programs. In Section 5.2, we present the experimental setup in detail. Section 5.3, Section 5.4, Section 5.5, Section 5.6, Section 5.7 and Section 5.8 present and discuss the results of the experiments. Following that, we briefly discuss the ordering sensitivity exhibited in some cases (Section 5.9). In Section 5.10, we focus on memory consumption (all experiments in the preceding sections feature only time measurements). Section 5.11 provides a short summary of the findings.

All our experiments were carried out on a Linux desktop machine (Lenovo Group Ltd., Morrisville, NC, USA) with the Intel Core i7-7700 processor (Intel Corp., Santa Clara, CA, USA) and 32 GiB of RAM. For each experiment, we measured the total wall-clock time of computing a maximum EE partition for the corresponding graph using the corresponding program.

5.1. Test Graph Sets

We tested our algorithms on the six following graph families:

• Cycle graphs. The k-cycle graph ($C_k$; $k\ge 3$) is composed of k vertices and k edges. (We chose k to denote the parameter of the family (instead of the more usual n) to avoid the confusion between the parameter and the number of vertices (n), which may, in general, be different from k.) The edges are $(k,1)$ and $(i,i+1)$ for $i\in \{1,\dots ,k-1\}$. The number of automorphisms of $C_k$ is $2k$.
• Complete graphs. The k-complete graph ($K_k$; $k\ge 3$) is composed of k vertices and ${\displaystyle \frac{1}{2}}k(k-1)$ edges, since there is an edge between each pair of vertices. The number of automorphisms of $K_k$ is $k!$.
• Hypercube graphs. The k-hypercube graph ($Q_k$; $k\ge 2$) is made up of $2^k$ vertices, which are customarily identified by k-bit vectors, and an edge $(u,v)$ whenever the Hamming distance between the bit vectors representing u and v is exactly 1. The graph $Q_k$ has $2^{k-1}k$ edges and $2^{k}k!$ automorphisms.
• Square-grid graphs. The k-square-grid graph ($S_k$; $k\ge 2$) consists of $k\times k$ vertices denoted by $(i,j)$ (for $i\in \{1,\dots ,k\}$ and $j\in \{1,\dots ,k\}$) and an edge between $(i,j)$ and $(p,q)$ whenever either $|i-p|=1$ and $j=q$ or $i=p$ and $|j-q|=1$. Every graph from this family has exactly 8 automorphisms.
• Cross-polytope graphs. The graph ${\mathit{CP}}_k$ ($k\ge 2$) has $2k$ vertices, denoted 1, …, $2k$, and $2k(k-1)$ edges. Vertices u and v are connected if and only if $|u-v|\ne k$. The graph ${\mathit{CP}}_k$ has $2^{k}k!$ automorphisms.
• GI-graphs. These highly symmetrical graphs [25] are parameterized by an integer $k\ge 3$ and a multiset $J=\{j_0,j_1,\dots ,j_{t-1}\}$ such that $1\le j_k\le k-1$ and $j_k\ne k/2$ for $k\in \{0,\dots ,t-1\}$. The graph $\mathit{GI}(k;J)$ (or $\mathit{GI}(k;j_0,j_1,\dots ,j_{t-1})$) comprises $t\times k$ vertices (denoted $(s,v)$ for $s\in {\mathbb{Z}}_t=\{0,\dots ,t-1\}$ and $v\in {\mathbb{Z}}_k=\{0,\dots ,k-1\}$) and

• an edge between $(s,v)$ and $(s^{\prime },v)$ for all distinct $s,s^{\prime }\in {\mathbb{Z}}_t$ and all $v\in {\mathbb{Z}}_k$;
• an edge between $(s,v)$ and $(s,v+j_s)$ for all $s\in {\mathbb{Z}}_t$ and all $v\in {\mathbb{Z}}_k$, where + is performed modulo k;
• an edge between $(s,v)$ and $(s,v-j_s)$ for all $s\in {\mathbb{Z}}_t$ and all $v\in {\mathbb{Z}}_k$, where − is performed modulo k.

For the sake of conciseness, we will not reproduce the formula to compute the number of automorphisms here and instead refer the interested reader to the original paper [25].

In contrast with the remaining graph sets, which are parameterized by a single integer, there are multiple ways to build a meaningful family of GI-graphs. We decided to fix $k=30$ and restrict the elements of the multiset J to belong to the set $\{2,3,5\}$, with additional stipulations that at least two elements of J be distinct, that $\left|J\right|\le 10$, and that the number of automorphisms not exceed $2^{63}-1$, the upper bound for Sage’s integral data type. The graphs in the family were ordered primarily by the increasing $t=\left|J\right|$, starting with $t=2$, and secondarily by the increasing number of automorphisms.

The reason for choosing these graph families is twofold. First, all families except for the GI-graphs are parameterized by a single parameter, which is directly associated with the size of the graph. Second, to determine the merit of the improved algorithm, we have to test it on graphs with a sizable number of automorphisms, since these are likely to have large maximum EE scores. Complete graphs, hypercube graphs, and cross-polytope graphs are well known to be highly symmetric, while the less-known GI-graph family was—according to its inventors [25]—specifically designed to be rich in the number of automorphisms. Cycle graphs and square-grid graphs are somewhat different in this regard but, as we will see later, both families serve to illustrate some interesting aspects of the algorithm.

Table 3, Table 4, Table 5, Table 6, Table 7 and Table 8 give the properties of selected graphs from our test sets. For each family, we picked the first five members and the last five members on which we tested the improved algorithm. The columns in each table represent the parameter value (k or J), the number of vertices, the number of edges, the size of the automorphism group, and the score of a maximum EE partition given as the product of the factorials of the sizes of its classes, respectively. To save space, the multiset J is represented as the concatenation of its elements (for example, 223 stands for $\{2,2,3\}$).

Table 3. The cycle graph family.

k	$\left|\mathit{V}\right|$	$\left|\mathit{E}\right|$	$\left|\mathbf{Aut}\right({\mathit{C}}_{\mathit{k}}\left)\right|$	Score $\left({\mathcal{P}}^{*}\right)$
3	3	3	6	$3!=6$
4	4	4	8	$2!2!=4$
5	5	5	10	$2!=2$
6	6	6	12	$3!=6$
7	7	7	14	$2!=2$
…	…	…	…
96	96	96	192	$3!=6$
97	97	97	194	$2!=2$
98	98	98	196	$2!2!=4$
99	99	99	198	$3!=6$
100	100	100	200	$2!2!=4$

Table 4. The complete graph family.

k	$\left|\mathit{V}\right|$	$\left|\mathit{E}\right|$	$\left|\mathbf{Aut}\right({\mathit{C}}_{\mathit{k}}\left)\right|$	Score $\left({\mathcal{P}}^{*}\right)$
3	3	3	6	$3!=6$
4	4	6	24	$4!=24$
5	5	10	120	$5!=120$
6	6	15	720	$6!=720$
7	7	21	5040	$7!=5040$
…	…	…	…
21	21	210	≈5.1 × ${10}^{19}$	$21!\approx 5.1\times {10}^{19}$
22	22	231	≈1.1 × ${10}^{21}$	$22!\approx 1.1\times {10}^{21}$
23	23	253	≈2.6 × ${10}^{22}$	$23!\approx 2.6\times {10}^{22}$
24	24	276	≈6.2 × ${10}^{23}$	$24!\approx 6.2\times {10}^{23}$
25	25	300	≈1.6 × ${10}^{25}$	$25!\approx 1.6\times {10}^{25}$

Table 5. The hypercube graph family.

k	$\left|\mathit{V}\right|$	$\left|\mathit{E}\right|$	$\left|\mathbf{Aut}\right({\mathit{C}}_{\mathit{k}}\left)\right|$	Score $\left({\mathcal{P}}^{*}\right)$
2	4	4	8	$2!2!=4$
3	8	12	48	$4!=24$
4	16	32	384	$2!4!=48$
5	32	80	3840	$2!5!=240$
6	64	192	46,080	$2!6!=1440$
7	128	448	645,120	$2!7!=$ 10,080
8	256	1024	10,321,920	$2!8!=$ 80,640
9	512	2304	185,794,560	$2!9!=$ 725,760
10	1024	5120	3,715,891,200	$2!10!=$ 7,257,600

Table 6. The square-grid graph family.

k	$\left|\mathit{V}\right|$	$\left|\mathit{E}\right|$	$\left|\mathbf{Aut}\right({\mathit{C}}_{\mathit{k}}\left)\right|$	Score $\left({\mathcal{P}}^{*}\right)$
2	4	4	8	$2!2!=4$
3	9	12	8	$2!2!=4$
4	16	24	8	$2!2!=4$
5	25	40	8	$2!2!=4$
6	36	60	8	$2!2!=4$
…	…	…	…
38	1444	2812	8	$2!2!=4$
39	1521	2964	8	$2!2!=4$
40	1600	3120	8	$2!2!=4$
41	1681	3280	8	$2!2!=4$
42	1764	3444	8	$2!2!=4$

Table 7. The cross-polytope graph family.

k	$\left|\mathit{V}\right|$	$\left|\mathit{E}\right|$	$\left|\mathbf{Aut}\right({\mathit{C}}_{\mathit{k}}\left)\right|$	Score $\left({\mathcal{P}}^{*}\right)$
2	4	4	8	$2!2!=4$
3	6	12	48	$2!2!2!=8$
4	8	24	384	$4!=24$
5	10	40	3840	$5!=120$
6	12	60	46,080	$6!=240$
…	…	…	…
12	24	264	1,961,990,553,600	$12!=$ 479,001,600
13	26	312	51,011,754,393,600	$13!=$ 6,227,020,800
14	28	364	1,428,329,123,020,800	$14!\approx 8.7\times {10}^{10}$
15	30	420	42,849,873,690,624,000	$15!\approx 1.3\times {10}^{12}$
16	32	480	1,371,195,958,099,968,000	$16!\approx 2.1\times {10}^{13}$

Table 8. The GI-graph family.

J	$\left|\mathit{V}\right|$	$\left|\mathit{E}\right|$	$\left|\mathbf{Aut}\right(\mathit{GI}(30;\mathit{J})\left)\right|$	Score $\left({\mathcal{P}}^{*}\right)$
23	60	90	60	$3!=6$
25	60	90	60	$3!=6$
35	60	90	120	$2!3!=12$
235	90	180	60	$3!=6$
223	90	180	240	$2!2!3!=24$
…	…	…	…
22222222255	330	1980	≈2.5 × ${10}^{14}$	${(2!)}^{4}3!{(9!)}^2\approx 1.2\times {10}^{13}$
22233333335	330	1980	≈2.8 × ${10}^{14}$	${(3!)}^3{(7!)}^3\approx 2.8\times {10}^{13}$
22222333333	330	1980	≈3.2 × ${10}^{14}$	$2!{(5!)}^2{(6!)}^3\approx 1.1\times {10}^{13}$
22333333555	330	1980	≈7.0 × ${10}^{14}$	$2!{(3!)}^6{(6!)}^3\approx 3.5\times {10}^{13}$
22222222555	330	1980	≈7.6 × ${10}^{14}$	$2!{(3!)}^5{(8!)}^2\approx 2.5\times {10}^{13}$

Figure 3 and Figure 4 depict a handful of graphs from each test family. An exception is the GI family; instead of the graphs $\mathit{GI}(30;2,3)$ and $\mathit{GI}(30;2,3,5)$, the first and the fourth members of the family, we show the graphs $\mathit{GI}(9;2,3)$ and $\mathit{GI}(9;2,3,5)$, which are structurally similar but small enough to fit the width of a page.

Figure 3. Selected members of the cycle graph family, complete graph family, hypercube graph family, and square-grid graph family.

Figure 4. Selected members of the cross-polytope graph family and two sample GI-graphs.

5.2. Experimental Design

We performed 30 series of experiments, in which each of the five programs (Python–Sage implementations of the respective algorithms) was tested on each of the six graph families. The programs were defined as follows:

• Version 1 (the baseline program). The implementation of the baseline algorithm closely followed the pseudocode given in Algorithm 1.
• Version 2. For this version, we extended the baseline program with the improvement described in Section 4.4. In particular, for $k\ge 3$, we did not test a k-element subset of the current vertex set for being an EE set until we established that all its subsets are EE sets. Having found all k-element EE sets, we discovered potential $(k+1)$-element EE sets by voting.
• Version 3. To obtain the third program, we extended version 2 with the logic introduced in Section 4.5. Specifically, the construction of a candidate EE partition is cut short if we find out that its maximum attainable score cannot be greater than the score of the maximum complete or partial EE partition discovered so far.
• Version 4. Here, we used the findings presented in Section 4.6 to further enhance version 3. This means that we took advantage of the fact that EE sets themselves form equivalence classes in order to reduce the number of EE sets that have to be considered.
• Version 5 (the final program). By including the improvements explained in Section 4.7 (a rule to obtain a set of initial EE pairs directly from the generators of the current automorphism group and maintaining an EE-set-to-orbit dictionary on each level of recursion), we arrive at an implementation of the final algorithm; i.e., the one that is shown in Algorithms 2–5 in this paper.

Every version thus includes everything from its predecessor, together with an extra improvement. To ease the presentation, we use the wording ‘improvement $i\to i+1$’ to refer to the difference between version i and its successor. For instance, improvement $3\to 4$ refers to the improvement presented in Section 4.6, which distinguishes version 3 from version 4.

For each pair of a program and a graph family, we ran the program on the graphs in that family in the order of increasing parameter until we encountered the first graph that required more than one hour. Additionally, we stopped the series once the parameter k exceeded 100 (for all families except GI, where k was fixed at 30).

5.3. Results on the Cycle Graph Family

We present and discuss the results for each family separately. In this section, we focus on cycle graphs. Table 9 shows how the time consumption for each of the five programs depends on the growing parameter k (which, in this case, is equal to n, the number of vertices).

Table 9. Time consumption (in seconds) for cycle graphs ($C_k$).

k	Version 1	Version 2	Version 3	Version 4	Version 5
3	0.151	0.150	0.151	0.148	0.144
4	0.160	0.159	0.157	0.144	0.133
5	0.182	0.174	0.174	0.142	0.134
6	0.260	0.222	0.208	0.152	0.149
7	0.313	0.230	0.231	0.144	0.135
8	0.669	0.317	0.284	0.156	0.150
9	0.847	0.339	0.339	0.157	0.149
10	2.34	0.517	0.409	0.166	0.156
11	2.77	0.501	0.495	0.151	0.136
12	10.2	0.796	0.610	0.161	0.156
13	10.4	0.695	0.696	0.152	0.137
14	43.8	1.14	0.876	0.188	0.173
15	41.8	0.995	0.999	0.163	0.151
16	189	1.64	1.23	0.202	0.186
17	166	1.32	1.32	0.159	0.139
18	810	2.36	1.59	0.170	0.162
19	667	1.80	1.80	0.162	0.140
20	3460	3.12	2.23	0.232	0.216
21	2720	2.44	2.44	0.173	0.155
22	-	4.16	2.87	0.248	0.231
…	…	…	…	…	…
96	-	410	235	0.361	0.291
97	-	241	241	0.353	0.235
98	-	432	249	2.34	2.20
99	-	254	254	0.368	0.256
100	-	461	265	2.38	2.29

The baseline program tests the cover predicate for each subset of $\{1,\dots ,n\}$, so its time consumption clearly grows exponentially with the parameter k. This is true for every graph family.

Cycle graphs appear to be the easiest case for our experimental setup, since the number of edges and automorphisms grows linearly with the number of vertices. Indeed, even the baseline program managed to arrive to $C_{21}$ before hitting the 1-h time limit, and the final program did not reach this boundary until approximately $k=2000$. However, what is interesting is the seemingly anomalous growth of time consumption with respect to the parameter k for some versions; often, a larger graph required less time than a smaller one. This behavior, however, can be readily explained by the variation in the structure of maximum EE partitions with increasing k. As we showed in [9], the structure of the maximum EE partition depends on the divisibility of k with 2 and 3:

• If $k\in 3\mathbb{N}$ (i.e., if k is divisible by 3), a maximum EE partition consists of a single 3-element class, which is made up of three equally spaced vertices. (Needless to say, the rest of the EE partition consists of the singletons capturing the remaining $k-3$ vertices.)
• If $k\in 2\mathbb{N}\setminus 3\mathbb{N}$ (i.e., if k is even and not divisible by 3), a maximum EE partition consists of two 2-element classes; one of them comprises two antipodal vertices, and the other is formed by the two neighbors of one of the vertices from the first class.
• If $k\in \mathbb{N}\setminus (2\mathbb{N}\cup 3\mathbb{N})$ (i.e., if k is odd and not divisible by 3), a maximum EE partition consists of a single 2-element class, an arbitrary 2-element subset of V.

Figure 5 shows the growth of time consumption with respect to k for the combination of version 5 and all three subsets of $\mathbb{N}$. We can see that the cases $k\in 3\mathbb{N}$ and $k\in \mathbb{N}\setminus (2\mathbb{N}\cup 3\mathbb{N})$ are more favorable than the case $k\in 2\mathbb{N}\setminus 3\mathbb{N}$. If k is odd and not divisible by 3, the maximum EE partition comprises a single 2-element class, and once the algorithm discovers this class (any 2-element subset of V will do) and stabilizes the automorphism group with respect to it, the residual automorphism group only consists of the identity automorphism. On the first level of recursion in the function FindMaxEERec (Algorithm 2), the algorithm still tries a couple of other 2-element subsets of V to fill the role of the first class in the nascent EE partition, since not all 2-element subsets of V belong to the same orbit (for example, Table 2 lists the orbits of $C_6$). However, none of these alternatives can surpass the maximum score attained by the first choice.

Figure 5. The consumption of time as a function of k when running version 5 on cycle graphs.

The case $3\mathbb{N}$ is similar. Once the algorithm discovers a three-element EE set and stabilizes the automorphism group with respect to it, the residual automorphism group consists of a single automorphism. Again, the alternatives on the first-level of recursion cannot compete with the selection of the three-element EE set (which is tried first, since on each level of recursion, the algorithm considers the EE sets in the decreasing order of their size). This holds true even if k is divisible by 6. The alternative high-score EE partitions (those consisting of two 2-element classes) are discouraged, since $2!2!<3!$.

The case $2\mathbb{N}\setminus 3\mathbb{N}$ gives the algorithm more work. In contrast to the other two cases, the algorithm is not yet ‘almost done’ once it discovers the first EE set, since the residual automorphism group still covers a two-element set. Considering the aforementioned fact that not all 2-element vertex sets belong to the same orbit, the algorithm will have to consider multiple alternatives on two levels of recursion, rather than just one.

Focusing on individual versions, improvement $1\to 2$ vastly boosts performance, since it tests a larger candidate EE set for satisfying the cover predicate only after having determined that all of its subsets are exploratory equivalent. Since no cycle has an EE set larger than 3, version 2 never considers vertex sets of sizes 4, 5, etc., while the baseline algorithm does. Improvement $2\to 3$ speeds up the performance on even cycles, regardless of whether k is (also) divisible by 3; in this case, many EE partitions are composed of two classes, which means that enforcing a lower score bound during search will definitely help. Improvement $3\to 4$ provides a further boost, since most EE pairs have an orbit of size k (for example, the orbit of the EE pair {1, 2} consists of all pairs of adjacent vertices), and so the number of representative EE pairs will be significantly smaller than the total number of EE pairs. Improvement $4\to 5$ helps only marginally; as we shall see later, it is more beneficial in the presence of larger EE classes.

5.4. Complete Graphs

The maximum EE partition of the graph $K_k$ is simply $\{1,2,\dots ,k\mid \}$. Its score, $k!$, is equal to the number of automorphisms.

Table 10 shows the results for the family of complete graphs (again, k is the same as n, the number of vertices). As with cycle graphs, the baseline program tests the cover predicate for each subset of $\{1,\dots ,k\}$, so its time consumption can only grow exponentially with respect to k. Improvement $1\to 2$ has virtually no effect, since all subsets of $\{1,\dots ,k\}$ are EE sets; it does not matter whether we generate them from smaller to larger via voting or in some other manner. Improvement $2\to 3$ has a more significant impact: setting a lower bound for the maximum EE score does eliminate some competitive (but inferior or equivalent) EE partitions. Even greater savings are provided by improvement $3\to 4$, the reason for which is clear: for each EE set of size s, its orbit consists of all sets of s vertices. Consequently, for each s from 1 to k, we essentially work with a single EE set rather than $\left({\displaystyle \genfrac{}{}{0pt}{}{k}{s}}\right)$ EE sets. However, in the voting procedure, we still have to enumerate all $\left({\displaystyle \genfrac{}{}{0pt}{}{k}{s}}\right)$ EE sets in order to find the EE set(s) of size $s+1$, which is why we cannot escape exponential growth of time. Improvement $4\to 5$ also brings some benefits: the computation of the orbit of a (large) EE class may be costly, and so the set-to-orbit dictionary indeed saves some time.

Table 10. Time consumption (in seconds) for complete graphs ($K_k$).

k	Version 1	Version 2	Version 3	Version 4	Version 5
3	0.151	0.150	0.150	0.145	0.145
4	0.197	0.197	0.191	0.162	0.158
5	0.398	0.398	0.307	0.183	0.183
6	1.55	1.56	0.666	0.242	0.242
7	8.66	8.70	1.92	0.377	0.416
8	61.0	61.5	5.71	0.679	0.668
9	504	507	18.5	1.15	1.04
10	-	-	57.9	1.76	1.83
11	-	-	175	3.21	3.06
12	-	-	514	5.08	4.84
13	-	-	1520	8.32	8.28
14	-	-	-	13.9	13.7
15	-	-	-	21.9	20.8
16	-	-	-	34.2	34.2
17	-	-	-	56.7	54.6
18	-	-	-	91.4	87.1
19	-	-	-	153	133
20	-	-	-	243	218
21	-	-	-	396	348
22	-	-	-	673	592
23	-	-	-	1190	935
24	-	-	-	2120	1570
25	-	-	-	-	2780

5.5. Hypercube Graphs

A maximum EE partition of $Q_3$ is $\{000,011,101,110\mid \}$. For all other $k\ge 2$, one of the EE partitions of $Q_k$ is a partition ${\mathcal{P}}_k$ composed of two classes—one consisting of two antipodal vertices (say, $0^k$ and $1^k$), and the other consisting of the neighbors of one of these two vertices (say, $0^{k-1}1$, $0^{k-2}10$, $0^{k-3}{10}^2$, …, ${010}^{k-2}$, and ${10}^{k-1}$). It is strongly suspected (although not yet proven) that ${\mathcal{P}}_k$ is actually a maximum EE partition of $Q_k$.

As shown in Table 11, hypercube graphs are highly conducive to the improvements of the baseline algorithm. In particular, the largest graph successfully completed within the 1-h time limit by the baseline program and version 2 is $Q_4$ (16 vertices, 32 edges, 384 automorphisms), although version 2 spends only a hundredth of the time on it compared with version 1. Version 3 manages to process $Q_6$ (64 vertices, 192 edges, 46,080 automorphisms), whereas versions 4 and 5 reach as far as $Q_{10}$ (1024 vertices, 5120 edges, ≈3.7 × ${10}^9$ automorphisms).

Table 11. Time consumption (in seconds) for hypercube graphs ($Q_k$).

k	Version 1	Version 2	Version 3	Version 4	Version 5
2	0.159	0.158	0.157	0.143	0.134
3	1.71	0.709	0.358	0.166	0.163
4	2930	31.0	2.59	0.239	0.232
5	-	-	23.1	0.371	0.350
6	-	-	275	0.846	0.795
7	-	-	-	2.78	2.36
8	-	-	-	14.8	10.1
9	-	-	-	119	69.0
10	-	-	-	2330	1210

Improvement $1\to 2$ is almost always beneficial; a rare exception is the complete graph family, where every subset of $\{1,\dots ,k\}$ is an EE set. Improvement $2\to 3$ helps primarily because of the presence of large EE classes ($Q_k$ has an EE partition with a class of size k). Since the algorithm is designed to find large EE sets early in the process, it quickly sets the lower bound for the maximum EE score to $k!$, ruling out many candidate (partial) EE partitions.

Improvement $3\to 4$ helps because hypercube graphs have relatively few distinct orbits of EE sets, which are therefore fairly large on average. For example, the graph $Q_5$ has 496 two-element EE sets and 320 three-element EE sets, but only six distinct orbits of 2-element EE sets and a single orbit of 3-element EE sets. As a consequence, when the algorithm discovers an EE set of size 3, it will discover all the remaining 319 three-element EE sets just by computing the orbit of that set, without having to determine which of those 319 sets are covered by the current automorphism group and which are not.

The last improvement also makes itself felt. As with complete graphs, the reason for this result is the presence of large EE classes. If we avoid recomputing their orbits, we will certainly save some time.

5.6. Square-Grid Graphs

For the preceding two families (complete graphs and hypercube graphs), the size of the largest EE class is (almost) the same as the parameter k, so even with all the improvements, the time consumption grows exponentially with k. However, even if the size of the largest class is constant, we may still arrive at an exponential complexity. As we saw in Section 4.11, one such case is given by path graphs. Square-grid graphs represent another example. As evidenced in Table 12, the time increases exponentially with k even though for all $k\ge 2$, a maximum EE partition is composed of two classes of size 2, and no EE partition has a class of size 3. The reason is that square-grid graphs have a large number of small orbits of EE pairs, making it necessary to compute the costly cover predicate for a vast majority of EE pairs.

Table 12. Time consumption (in seconds) for square-grid graphs ($S_k$).

k	Version 1	Version 2	Version 3	Version 4	Version 5
2	0.158	0.157	0.156	0.143	0.133
3	1.09	0.264	0.218	0.162	0.152
4	130	0.594	0.391	0.212	0.192
5	-	1.88	0.769	0.313	0.287
6	-	3.28	1.45	0.524	0.481
7	-	10.7	2.49	0.811	0.755
8	-	14.8	4.27	1.32	1.19
9	-	46.5	7.04	2.01	1.91
10	-	48.9	10.4	3.02	2.90
11	-	144	18.2	4.83	4.68
12	-	134	27.7	6.97	6.72
13	-	337	38.7	9.79	9.53
14	-	279	52.3	13.5	13.2
15	-	702	72.2	18.2	18.1
16	-	569	94.2	24.3	23.8
17	-	1380	125	32.3	31.6
18	-	1070	160	41.5	41.0
19	-	2550	206	54.0	53.9
20	-	1870	259	67.9	68.5
21	-	-	327	87.3	86.7
22	-	-	405	107	108
23	-	-	500	135	135
24	-	-	612	166	166
25	-	-	746	204	203
26	-	-	903	249	248
27	-	-	1090	303	304
28	-	-	1300	368	368
29	-	-	1560	437	439
30	-	-	1840	524	525
31	-	-	2180	623	625
32	-	-	2560	731	735
33	-	-	3010	873	875
34	-	-	3500	1020	1020
35	-	-	-	1190	1200
36	-	-	-	1400	1380
37	-	-	-	1650	1640
38	-	-	-	1900	1900
39	-	-	-	2190	2190
40	-	-	-	2530	2490
41	-	-	-	2920	2920
42	-	-	-	3350	3310

To be more concrete, there are $k^2(k^2-1)/2$ unordered pairs (2-element sets) of vertices for the k-by-k grid. However, the size of the orbit of a pair may be 2, 4, or 8, regardless of k (Figure 6). As a consequence, the costly cover predicate has to be computed for more than $k^2(k^2-1)/16$ pairs. Considering the fact that computing the cover predicate takes exponential time, we should not wonder that the time consumption as a whole grows exponentially with k.

Figure 6. The graph $S_4$. The size of the orbit is 2 for the EE pairs along either diagonal (such as (0, 15) and (6, 9)), 4 for all other EE pairs (such as (0, 3), (0, 12), (0, 15), (1, 2), (1, 4), (1, 11), (1, 13), and (1, 14)) and for non-EE pairs along either diagonal (such as (0, 10) and (6, 12)), and 8 for all other pairs.

5.7. Cross-Polytope Graphs

One of the EE partitions of the graph ${\mathit{CP}}_k$ with vertices 1, 2, …, $2k$ is ${\mathcal{P}}_1=\{1,2,\dots ,k\mid \}$. Another is ${\mathcal{P}}_2=\{1,k+1\mid 2,k+2\mid \dots \mid k,2k\mid \}$. To see that these partitions are indeed exploratory equivalent, it is helpful to consider the complement of ${\mathit{CP}}_k$, which is composed of k distinct 2-vertex path graphs. (The complement of a graph $G=(V,E)$, i.e., the graph $\overline{G}=(V,\overline{E})$ with $\overline{E}=(V\times V)\setminus E$, has exactly the same automorphism group as the graph G and, hence, also the same EE partitions.) Since $k!>{(2!)}^k$ for all $k\ge 4$, ${\mathcal{P}}_1$ is a maximum EE partition for $k\ge 4$, whereas for $k=2$ and $k=3$, ${\mathcal{P}}_2$ attains a greater score.

Considering that a maximum EE partition is composed of a single large EE class for all but the smallest values of k, the performance of the algorithms on cross-polytope graphs is expected to exhibit a behavior similar to what we have seen on complete graphs. By inspecting Table 13, we can confirm that this is indeed the case.

Table 13. Time consumption (in seconds) for cross-polytope graphs (${\mathit{CP}}_k$).

k	Version 1	Version 2	Version 3	Version 4	Version 5
2	0.158	0.158	0.156	0.142	0.133
3	0.401	0.329	0.279	0.155	0.148
4	3.83	2.12	1.15	0.179	0.173
5	73.2	28.0	7.47	0.223	0.210
6	1700	436	81.5	0.346	0.326
7	-	-	522	0.663	0.632
8	-	-	3420	1.30	1.13
9	-	-	-	2.80	2.42
10	-	-	-	5.78	5.07
11	-	-	-	15.1	12.0
12	-	-	-	36.0	26.0
13	-	-	-	99.4	63.3
14	-	-	-	314	186
15	-	-	-	1030	569
16	-	-	-	3500	1910

5.8. GI-Graphs

For this family, it is harder to draw definite conclusions, as both the number of automorphisms and the maximum EE score may vary widely between successive members of the family. However, every maximum EE partition in the test set consists of at least one class of size three or more, and many partitions contain even larger classes. For this reason, it is expected that all improvements, except perhaps the last, make themselves felt. As shown in Table 14, our expectations have been met as far as improvements $1\to 2$, $2\to 3$, and $3\to 4$ are concerned. However, improvement $4\to 5$ sometimes unexpectedly increases the time consumption. The reason is that when finding EE pairs, version 5 starts with the pairs that can be obtained directly from the generators, although it ultimately produces the same set of EE pairs as version 4, only their order in the list differs. However, a different order of EE pairs may result in a different order of discovering candidate EE partitions, which, in turn, may lead to a faster or a slower progress towards a maximum EE partition. A brief discussion on ordering sensitivity is provided in Section 5.9.

Table 14. Time consumption (in seconds) for GI-graphs ($\mathit{GI}(30,J)$).

J	Maximum EE Score	Version 1	Version 2	Version 3	Version 4	Version 5
23	$3!$	-	54.6	15.0	0.262	0.231
25	$3!$	-	55.6	14.9	0.263	0.233
35	$2!3!$	-	985	18.4	0.906	0.857
235	$3!$	-	170	25.7	0.378	0.325
223	${(2!)}^{2}3!$	-	-	84.7	5.69	5.56
225	${(2!)}^{2}3!$	-	-	85.2	5.81	5.60
233	${(2!)}^{3}3!$	-	-	105	6.03	5.89
335	${(2!)}^{4}3!$	-	-	122	12.1	12.0
255	${(2!)}^{5}3!$	-	-	153	19.3	18.9
…	…	…	…	…	…	…
22223	$3!{(4!)}^2$	-	-	3300	23.5	22.8
22225	$3!{(4!)}^2$	-	-	3300	23.7	22.8
22333	$2!{(3!)}^4$	-	-	2320	85.5	82.8
22255	${(2!)}^4{(3!)}^3$	-	-	2610	141	156
23555	${(3!)}^6$	-	-	2730	116	116
23333	$3!{(4!)}^3$	-	-	-	50.3	48.9
…	…	…	…	…	…	…
2333555555	${(3!)}^4{(6!)}^5$	-	-	-	3020	2840
2333333333	$3!{(9!)}^3$	-	-	-	668	651
3333355555	${(2!)}^2{(5!)}^8$	-	-	-	2080	2120
3333333335	$2!3!{(9!)}^3$	-	-	-	856	874
2222555555	$2!{(4!)}^2{(6!)}^5$	-	-	-	1360	1360

The GI-graphs provide a good example for the observation that the sheer number of automorphisms (and, in turn, the closely related maximum EE score) does not directly affect the time consumption. Figure 7 shows a plot of time consumption versus the number of automorphisms for the graphs with $\left|J\right|=10$ (note that the scale on the x axis is logarithmic) and version 5. While we may observe a generally upward trend, it is adequately explained by the size of the maximum EE class (which directly affects the computational complexity) and the number of EE classes (which has an indirect effect, through a potentially greater amount of backtracking).

Figure 7. The consumption of time as a function of the number of automorphisms when running version 5 on GI-graphs with $k=30$ and $\left|J\right|=10$.

5.9. Ordering Sensitivity

As we noted in Section 5.8, version 5 in some (rare) cases performed more slowly than version 4. This apparent anomaly is not directly associated with improvement $4\to 5$; rather, it stems from the fact that it is important how the EE sets considered in the for-loop of the function FindMaxEERec (Algorithm 2) are ordered. We already know that they have to be ordered from the largest to the smallest, so as to set a high global lower bound ($s^{*}$ in Algorithm 2) for the maximum EE score early in the process, but sometimes even the order of EE sets of the same size matters.

To provide an example, let us focus on the graph in Figure 8. This graph has several 2-element EE sets, but no 3-element EE set. If the algorithm picks the EE set {1, 2} on the first level of recursion, it will select either the EE set {3, 4} or the set {5, 6} on the second level. In either case, the bound $s^{*}$ will be set to $2!2!=4$, preventing all of the alternative EE sets from being chosen in the subsequent iterations of the for-loop back on the first level of recursion. However, if $\{3,4\}$ is chosen on the first level, the algorithm will not find any EE set on the second level, and the bound $s^{*}$ will be set only to $2!=2$. Consequently, the algorithm will still have to consider the alternative EE sets on the first level.

Figure 8. A graph to illustrate ordering sensitivity.

5.10. Memory Consumption

In the previous sections, we focused exclusively on time consumption. Now, we are interested in the peak amount of memory allocated by our implementations, which we measured using Python’s standard tracemalloc utility. This utility only measures the amount of memory occupied by Python objects (such as lists, tuples, sets, and dictionaries), whereas objects created within the Sage framework (such as graphs or permutation groups) are not tracked. Fortunately, this is not really an issue, since most of the data that we actually work with and that actually tangibly scale with the growing parameter k are represented as usual Python objects. For example, a set of EE sets is represented as a Python set (or list) of Python tuples, not as a Sage object opaque to the Python interpreter. Graphs and permutation groups are stored as Sage objects, but these may be regarded as the input data. Furthermore, recall that a permutation group is stored efficiently, as a set of generators rather than a full set of automorphisms.

Table 15 shows the peak amount of memory allocated by version 5 for each graph family except the GI-graphs. A major memory consumer is the voting process in the FindLargerEESets function. For example, in the case of the complete graphs, the orbit of an m-element EE set consists of all m-element subsets of the vertex set, and each of those sets casts a vote for all of its one-element extensions. All m-element sets and their votes are simultaneously kept in memory. Another non-negligible source of memory allocation is the set-to-orbit dictionary introduced in version 5 to prevent duplicate time-consuming orbit computations.

Table 15. Peak memory allocation (in MiB) when running version 5 on each graph family.

k	${\mathit{C}}_{\mathit{k}}$	${\mathit{K}}_{\mathit{k}}$	${\mathit{Q}}_{\mathit{k}}$	${\mathit{S}}_{\mathit{k}}$	${\mathit{CP}}_{\mathit{k}}$
2	-	-	0.710	0.709	0.709
3	3.53	3.53	1.14	1.19	1.12
4	3.14	3.55	1.32	1.41	1.14
5	3.13	3.58	1.53	1.95	1.21
6	3.56	3.60	2.15	2.69	1.35
7	3.14	3.65	10.2	3.84	1.42
8	3.61	3.66	89.4	6.38	1.93
9	3.56	3.72	755	7.04	3.87
10	3.67	3.74	11,200	8.73	9.08
11	3.15	3.88	-	9.34	26.3
12	3.59	4.10	-	10.1	78.6
13	3.16	4.68	-	11.3	254
14	3.79	5.71	-	12.8	725
15	3.60	8.15	-	14.7	2300
16	3.88	12.9	-	16.0	7190
17	3.17	23.1	-	19.9	-
18	3.65	43.6	-	22.6	-
19	3.18	85.5	-	25.6	-
20	4.05	171	-	33.3	-
21	3.60	348	-	36.7	-
22	4.19	707	-	40.9	-
23	3.24	1440	-	49.9	-
24	3.71	2950	-	58.7	-
25	3.24	6100	-	67.2	-

Unsurprisingly, the peak amount of allocated memory grows with k in a manner similar to time consumption. For example, the complete graphs exhibit an exponential growth of memory consumption, which can be readily explained by the above-mentioned fact that all $\left({\displaystyle \genfrac{}{}{0pt}{}{n}{m}}\right)$ m-element subsets of the vertex set have to be kept in memory before proceeding to $(m+1)$-element EE sets. By contrast, for the cycle graph family, the growth is much more gentle, but the ‘bumps’ are similar to those observed in the time consumption data (cf. the rightmost column of Table 16). In particular, the cases where the number of vertices is divisible by 2 but not by 3 are more demanding than the other cases, both temporally and spatially.

Table 16. Peak memory allocation (in MiB) when running each version on the complete graphs family.

k	Version 1	Version 2	Version 3	Version 4	Version 5
3	3.56	3.56	3.56	3.53	3.53
4	3.67	3.67	3.64	3.56	3.55
5	3.81	3.82	3.78	3.59	3.58
6	4.14	4.11	3.99	3.62	3.60
7	5.07	4.98	4.44	3.66	3.65
8	7.21	7.20	4.77	3.69	3.67
9	8.42	8.57	6.14	3.70	3.71
10	-	-	8.44	3.80	3.75
11	-	-	9.76	3.92	3.88
12	-	-	9.92	4.06	4.10
13	-	-	11.9	4.46	4.68
14	-	-	-	5.09	5.71
15	-	-	-	5.92	8.15
16	-	-	-	8.41	12.9
17	-	-	-	13.1	23.1
18	-	-	-	22.5	43.6
19	-	-	-	40.7	85.5
20	-	-	-	78.3	171
21	-	-	-	152	348
22	-	-	-	303	707
23	-	-	-	601	1440
24	-	-	-	1210	2950
25	-	-	-	-	6100

Table 16 shows how the peak memory consumption for the complete graphs family differs between the versions of the algorithm. Since all subsets of the vertex set are EE sets, there is no significant difference between versions 1 and 2. However, versions 3 and 4 both reduce the memory consumption: maintaining and imposing the lower bound for the maximum EE score and taking into account the equivalence of EE sets both reduce the number of EE sets that have to be simultaneously kept in memory. Version 5 introduces the set-to-orbit dictionary and thus again causes the memory consumption to increase.

5.11. Summary of the Results

For all graph families, there is a huge leap from the baseline algorithm (version 1) to the improved algorithm (version 5). However, the influence of the individual improvements varies from family to family. Improvement $1\to 2$ provides a large boost for all families except for complete graphs, where all subsets of V are exploratory equivalent and so it does not matter whether larger EE sets are simply generated or built in a bottom-up manner by voting. Improvement $2\to 3$ is evident for all graph families, but its effect is comparatively weak for cycles and square grids, where maximum EE partitions are made up of a small number (1 or 2) of small classes (of size 2 or 3). Improvement $3\to 4$ is once more a major contribution to the overall speed; it is weakest (but still considerable) in the case of square grids, where the orbit sizes are small and independent of k. Lastly, improvement $4\to 5$ does not have a profound impact, but is still noticeable in the presence of large EE classes. We can thus conclude that all improvements are meaningful and may recommend that the proposed improved algorithm be used for finding maximum exploratory equivalent partitions in graphs.

In Table 17, we provide yet another view on the benefits of individual improvements. For each version of the algorithm and for each of the four selected graph families, we give the largest graph that was processed by that version within an hour. (We decided to omit cycle graphs and GI-graphs, where we did not strictly adhere to the 1-h time limit.) We can observe a significant increase in all four quantities (the parameter k, the number of vertices, the number of edges, and the number of automorphisms) between the first and the last version, once again confirming the value of the proposed approach.

Table 17. The largest graph processed within an hour.

Family	Quantity	Version 1	Version 2	Version 3	Version 4	Version 5
$K_k$	k	9	9	13	24	25
	$\left|V\right|$	9	9	13	24	25
	$\left|E\right|$	36	36	78	276	300
	$\left|\mathrm{Aut}\right(G\left)\right|$	362,880	362,880	≈6.2 × ${10}^9$	≈6.2 × ${10}^{23}$	≈1.6 × ${10}^{25}$
$Q_k$	k	4	4	6	10	10
	$\left|V\right|$	16	16	64	1024	1024
	$\left|E\right|$	32	32	192	5120	5120
	$\left|\mathrm{Aut}\right(G\left)\right|$	384	384	46,080	≈3.7 × ${10}^9$	≈3.7 × ${10}^9$
$S_k$	k	4	20	34	42	42
	$\left|V\right|$	16	400	1156	1764	1764
	$\left|E\right|$	24	760	2244	3444	3444
	$\left|\mathrm{Aut}\right(G\left)\right|$	8	8	8	8	8
${\mathit{CP}}_k$	k	6	6	8	16	16
	$\left|V\right|$	12	12	16	32	32
	$\left|E\right|$	60	60	112	480	480
	$\left|\mathrm{Aut}\right(G\left)\right|$	46,080	46,080	$1.0\times {10}^7$	$1.4\times {10}^{18}$	$1.4\times {10}^{18}$

6. Conclusions

In this paper, we presented an improved algorithm for finding a maximum exploratory equivalence in a graph. First, we observed that the classes that make up an EE partition can be discovered from smaller to larger by an efficient voting procedure. Following that, we found that maintaining the lower bound for the maximum EE score rules out many non-maximum EE partitions before they are actually built. Third, we exploited the symmetry in EE sets themselves to reduce the number of the subsets of the vertex set that have to be checked as potential candidates for EE sets.

As shown by the experiments, these improvements had a significant impact on performance. The improved algorithm was tested on multiple symmetry-rich graph families, and a notable reduction in time consumption was observed for each of them. Despite the fact that the worst-case complexity of the algorithm remains exponential (the underlying problem is NP-hard), we may claim that we have significantly improved the practicability of the problem of finding a maximum exploratory equivalent partition of a graph. To the best of our knowledge, the approach presented in this paper is the first improvement of the exact algorithm for finding a maximum EE partition.

We may now ask ourselves how much room for additional improvement we still have, save from rewriting the algorithm in a more efficient programming language such as C/C++, where we cannot expect more than a constant-factor boost. As we proved in our previous paper [8], we cannot possibly hope for a polynomial algorithm without causing a collapse in the computational complexity hierarchy. We have no proof, but we sincerely doubt that a significant further improvement can be brought about for graph families where the size of the largest EE set grows proportionally with the graph size (such as complete graphs and cross-polytope graphs). However, there are graph families, such as square grids, where the EE sets are small and even the size of the automorphism group grows slowly or remains constant with graph size, but the time to find a maximum EE partition still grows exponentially, since there are many instances of small but not directly related EE sets. For such cases, we might have to devise a stronger model of relationship between EE sets or more thoroughly exploit the information ‘hidden’ in the generators of the input graph’s automorphism group. Currently, only a relatively small proportion of EE sets are typically extracted directly from the generators, while all others are found by computing the orbit or the cover predicate. If we were able to extract more EE sets (or non-EE sets) without resorting to costly measures, the algorithm could be further improved.