Accelerating Maximal Clique Enumeration via Graph Reduction

Wen Deng Fudan UniversityShanghaiChina [email protected] , Weiguo Zheng Fudan UniversityShanghaiChina [email protected] and Hong Cheng The Chinese University of Hong KongHong KongChina [email protected]

Abstract.

As a fundamental task in graph data management, maximal clique enumeration (MCE) has attracted extensive attention from both academic and industrial communities due to its wide range of applications. However, MCE is very challenging as the number of maximal cliques may grow exponentially with the number of vertices. The state-of-the-art methods adopt a recursive paradigm to enumerate maximal cliques exhaustively, suffering from a large amount of redundant computation. In this paper, we propose a novel reduction-based framework for MCE, namely RMCE, that aims to reduce the search space and minimize unnecessary computations. The proposed framework RMCE incorporates three kinds of powerful reduction techniques including global reduction, dynamic reduction, and maximality check reduction. Global and dynamic reduction techniques effectively reduce the size of the input graph and dynamically construct subgraphs during the recursive subtasks, respectively. The maximality check reduction minimizes the computation for ensuring maximality by utilizing neighborhood dominance between visited vertices. Extensive experiments on 18 real graphs demonstrate the effectiveness of our proposed method. It achieves remarkable speedups up to $44.7\times$ compared to existing approaches.

PVLDB Reference Format:
PVLDB, 14(1): XXX-XXX, 2024.
doi:XX.XX/XXX.XX This work is licensed under the Creative Commons BY-NC-ND 4.0 International License. Visit https://creativecommons.org/licenses/by-nc-nd/4.0/ to view a copy of this license. For any use beyond those covered by this license, obtain permission by emailing [email protected]. Copyright is held by the owner/author(s). Publication rights licensed to the VLDB Endowment.
Proceedings of the VLDB Endowment, Vol. 14, No. 1 ISSN 2150-8097.
doi:XX.XX/XXX.XX

PVLDB Artifact Availability:
The source code, data, and/or other artifacts have been made available at %leave␣empty␣if␣no␣availability␣url␣should␣be␣setURL_TO_YOUR_ARTIFACTS.

1. Introduction

As one of the most important cohesive structures in graph data, clique is closely related to other fundamental problems like independent set problem (Tsukiyama et al., 1977) and graph coloring problem (Dukanovic and Rendl, 2007). In an undirected graph $G$ , a clique refers to a subgraph of $G$ where every pair of vertices are adjacent. A clique is maximal when no other vertices can be included to form a larger clique. Maximal clique enumeration (MCE) is the task of listing all the maximal cliques in a graph $G$ and can be applied in a variety of fields, such as computational biology (Töpfer et al., 2014; Abu-Khzam et al., 2005; Yu et al., 2006; Matsunaga et al., 2009), social network (Wen et al., 2016; Lu et al., 2018), and wireless communication networks (Biswas et al., 2013).

1.1. Existing Methods and Limitations

Refer to caption — Figure 1. Illustration of the gap between the number of maximal cliques and the number of vertex visits (the horizontal axis is log-scaled).

Input: Partial clique

R

, Candidate set

P

, Forbidden set

X

Output: All maximal cliques in

G[P]

restricted by

X

1 if $P=\emptyset$ and $X=\emptyset$ then

2 report

R

as a maximal clique

3for $v\in P$ do

BK(R\cup\{v\},P\cap N(v),X\cap N(v)

)

P\leftarrow P\setminus\{v\}

X\leftarrow X\cup\{v\}

Algorithm 1

BK(R,P,X

)

BKdegen (Eppstein et al., 2010) and BKrcd (Li et al., 2019b) are two state-of-the-art algorithms for MCE, both of which adopt the Bron-Kerbosch (BK) framework (Bron and Kerbosch, 1973) in Algorithm 1 that recursively enumerates all maximal cliques. The framework involves three sets, i.e., $R,P$ , and $X$ , where $R$ stores the partial clique, $P$ records the candidate set, and $X$ contains vertices that have already been visited to ensure the maximality (also called a forbidden set). The recursive function $BK$ initializes $R,P$ , and $X$ as $\emptyset,V,$ and $\emptyset$ , respectively. To expand a new branch, a vertex $v$ is moved from $P$ to $R$ , Then $P$ and $X$ are updated as $P\cap N(v)$ and $X\cap N(v)$ , respectively (lines 3-4). After completing this search branch, vertex $v$ is moved from $P$ to $X$ (lines 5-6). Once both $P$ and $X$ are empty, $R$ is reported as a maximal clique (lines 1-2). BKdegen (Eppstein et al., 2010) combines the degeneracy order and pivot selection, effectively bounding the subproblem scale of each vertex by the degeneracy $\lambda$ of graph $G$ . BKrcd (Li et al., 2019b) leverages the dense nature of subproblems to enumerate maximal cliques in a top-down manner. A question naturally arises “can we make the task of maximal clique enumeration even faster?”

In practice, a substantial amount of overhead is incurred due to the need for repeated visits to specific vertices within the graph during the process of maximal clique enumeration. Figure 1 presents the distribution of the number of maximal cliques in which each vertex appears and the number of visits to each vertex by different algorithms. The results are averaged over 7 real graphs from SNAP (Leskovec and Krevl, 2014). We observe a notable gap between the number of maximal cliques and the number of vertex visits, especially for low-degree vertices. For instance, on average, BKdegen and BKrcd visit degree-3 vertices approximately 48.6 million and 44.6 million times, respectively. However, the average number of maximal cliques involving degree-3 vertices is only about 4 million. This large gap suggests that there is significant scope for further improvement in time efficiency.

Motivated by this observation, in order to enhance the performance, the key idea is to develop effective techniques to bridge this gap by reducing the graph size and minimizing unnecessary vertex visits during the recursive computation process, while preserving the completeness of maximal cliques.

1.2. Our Approach and Contributions

Example 1.

Let us consider the graph at the top of Figure 2, where vertex $u_{10}$ participates in just a single maximal 2-clique with its only one neighbor $u_{4}$ . However, following the BK framework in Algorithm 1, there are at most 5 (i.e., the number of neighbors of $u_{4}$ ) subproblems involved in the recursive computation, where the candidate set $P$ and the forbidden set $X$ may be intersected with the neighborhood of $u_{4}$ . This will lead to unnecessary visits of vertex $u_{10}$ . By removing vertex $u_{10}$ and its corresponding edge, we can prevent their duplicate visits during the recursion, significantly reducing the computation cost. Meanwhile, we can ensure the completeness of solutions by reporting the maximal cliques that include the removed vertex $u_{10}$ in advance.

Inspired by the example above, we propose a novel reduction-based framework for maximal clique enumeration, namely RMCE, that incorporates three kinds of powerful reduction techniques including global reduction, dynamic reduction, and maximality check reduction.

(1) Global Reduction. Given a graph $G$ , RMCE removes the low-degree vertices (whose degree is not larger than 2), because we can identify and maintain the maximal cliques involving these deleted vertices beforehand. Moreover, we remove edges that do not form triangles with other edges throughout the graph, as they directly constitute maximal 2-cliques. For example, in Figure 2, the edges $(u_{2},u_{6})$ and $(u_{3},u_{7})$ can be removed as they are not contained in any other cliques, forming maximal cliques themself. Removing these vertices and edges can substantially reduce redundant computations during the recursive procedure.

(2) Dynamic Reduction. Enumerating maximum cliques operates in a recursive manner, creating an extensive number of subtasks (also named subproblems). In each subtask, a subgraph will be dynamically constructed such that new degree-zero and degree-one vertices may appear. RMCE recursively reduces the subgraph size by removing these vertices. Moreover, the subgraph is usually very dense and may contain the vertices that are adjacent to all other vertices in the candidate set $P$ . Since every maximal clique in this subtask must contain these vertices, we can move these vertices from the candidate set $P$ into the partial clique $R$ directly, and thus reduce the number of recursive calls (we call it dynamic degree- $\lvert P-1\rvert$ reduction). In the BK algorithm with pivot selection, each recursive call takes $O((|P|+|X|)^{2})$ to choose a pivot. If $k$ recursive calls are eliminated in a subproblem, the time cost will be reduced to $O((|P|+|X|)^{2})$ from $O((k+1)(|P|+|X|)^{2})$ . For example, in the second subgraph of the subproblem created by expanding $u_{8}$ in the search tree in Figure 2, $u_{6}$ and $u_{7}$ become new low-degree vertices that can be reduced. Removing $u_{6}$ and $u_{7}$ will result in pruning the branches expanded by $u_{6}$ and $u_{7}$ . In the left branch, $u_{1},u_{2}$ , and $u_{3}$ are adjacent to all other vertices in the subgraph, we can move them to the partial clique $R$ together, thus decreasing the number of recursive calls from 3 to 1.

(3) Maximality Check Reduction. The concept “maximal clique” involves two criteria: being a clique and achieving maximality. However, the existing methods have primarily focused on reducing the candidate vertices, with little attention given to optimizing the forbidden set $X$ that is used to perform maximality checks. The forbidden set size $\lvert X\rvert$ can be quite large, but not every vertex in $X$ is required in many subtasks, especially when the neighbors of a vertex (e.g., $u_{i}\in X$ ) are contained by the neighbors of another vertex (e.g., $u_{j}\in X$ ). In such cases, this vertex (e.g., $u_{i}$ ) can be removed safely from $X$ without reporting cliques that are not maximal. As studied in (Han et al., 2018), set intersections take 73.6% of the running time in MCE. Since the forbidden set $X$ is frequently intersected during the recursion of MCE, reducing the size of $X$ can lead to a reduction in the cost of set intersection operations. We develop an efficient algorithm with linear space overhead that minimizes the forbidden set $X$ , significantly reducing unnecessary computations.

In summary, we make the following contributions in this paper.

•

To the best of our knowledge, we are the first to propose a reduction-based framework, namely RMCE, for enumerating maximal cliques.
•

We develop powerful global reduction techniques and dynamic reduction techniques that effectively reduce the size of the input graph globally and the size of subgraphs in recursive subtasks, respectively.
•

We introduce a novel concept of maximality check reduction for maximal clique enumeration and propose an efficient algorithm to minimize the forbidden set $X$ .
•

The proposed graph reduction techniques above are orthogonal to the existing BK-based methods for maximal clique enumeration.
•

Extensive experiments on 18 real networks demonstrate that our proposed algorithms achieve significant speedups compared to state-of-the-art approaches.

2. Problem Definition and Preliminary

In this section, we first formally define the problem in Section 2.1 and then introduce two state-of-the-art methods in Section 2.2. Table 1 lists the frequently-used notations in the paper.

2.1. Problem Formulation

Let $G=(V,E)$ be an undirected graph with $n=\lvert V\rvert$ vertices and $m=\lvert E\rvert$ edges. The neighbor vertices of a vertex $V$ in $G$ are denoted as $N(v)$ , and the degree of $v$ is denoted as $d(v)=\lvert N(v)\rvert$ . The common neighbors of vertices in $S$ are denoted as $C(S)=\cap_{v\in S}N(v)$ .

Definition 0.

(Induced Subgraph). Given a subset $S$ of $V$ , an induced subgraph $G[S]$ is defined as $G[S]=(S,E^{\prime})$ , where $S\subseteq V$ and $E^{\prime}=\{(u,v)\in E\mid u,v\in S\}$ .

Let $N_{S}(v)$ denote the set of vertices in $S$ that are adjacent to vertex $v$ in graph $G$ , and let $d_{S}(v)$ denote the number of such vertices, that is, $N_{S}(v)=N(v)\cap S$ and $d_{S}(v)=\lvert N_{S}(v)\rvert$ .

Definition 0.

( $k$ -Core) Given a graph $G=(V,E)$ , an induced subgraph $G[S]$ is a $k$ -core if it satisfies that for every vertex $v\in S$ , $d_{S}(v)\geq k$ , and for every subset $S^{\prime}\subset S$ , the induced subgraph $G[S^{\prime}]$ is not a $k$ -core.

Definition 0.

(Core Number) Given a graph $G=(V,E)$ , the core number of a vertex $v$ is the maximum value $k$ of a $k$ -core that contains $v$ . The core number of a graph is the maximum core number among all its vertices.

Definition 0.

(Degeneracy Order) Given a graph $G=(V,E)$ , the degeneracy of $G$ , denoted by $\lambda$ , is equal to the core number of $G$ . The order of vertices $\overrightarrow{V}=\{v_{1},v_{2},v_{3},\ldots,v_{n}\}$ is called the degeneracy order of $G$ if vertex $v_{i}$ has the minimum degree in every induced subgraph $G[\{v_{i},v_{i+1},\ldots,v_{n}\}]$ .

The degeneracy order can be efficiently computed in linear time by iteratively removing the vertex with the smallest degree from the graph. In this order, each vertex $v_{i}$ has at most $\lambda$ neighbors in the induced graph $G[\{v_{i},v_{i+1},\ldots,v_{n}\}]$ among its later neighbors. We use $N^{-}(v)$ and $N^{+}(v)$ to denote the earlier neighbors and later neighbors of vertex $v$ , respectively.

Table 1. Notations

Notations	Descriptions
$G=(V,E)$	Undirected graph $G$ with vertex set $V$ and edge set $E$
$N(v)$	Neighbors of vertex $v$
$C(S)$	Common neighbors of vertices in $S$ , i.e., $\cap_{v\in S}N(v)$
$d(v)$	Degree of vertex $v$ , i.e., $d(v)=\|N(v)\|$
$G[S]$	A subgraph of $G$ induced by $S\subseteq V$
$d_{max}$	Maximum degree of a graph
$N_{S}(v)$	Neighbors of $v$ in set $S$ , i.e., $N_{S}(v)=N(v)\cap S$
$d_{S}(v)$	Number of neighbors of $v$ in set $S$ , i.e., $d_{S}(v)=\|N_{S}(v)\|$
$\lambda$	Degeneracy of a graph
$N^{+}(v)$	Neighbors of $v$ whose order is larger than $v$
$N^{-}(v)$	Neighbors of $v$ whose order is smaller than $v$
$R$	Partial clique
$P$	Candidate set
$X$	Forbidden Set
$(R,P,X)$	Subproblem with $R$ , $P$ , and $X$
$mc(G)$	Maximal cliques in graph $G$
$\tilde{mc}(R,P,X)$	Maximal cliques in subproblem $(R,P,X)$
$\alpha(\Delta V,\Delta E)$	Maximal cliques containing vertices in $\Delta V$ or edges in $\Delta E$
$\tilde{\alpha}(R,\Delta P,X)$	Maximal cliques containing vertices in $\Delta P$ in subproblem $(R,\Delta P,X)$

Definition 0.

(Clique). An induced subgraph $G[S]$ of $G=(V,E)$ is called a clique if there is an edge $(u,v)\in E$ for any two vertices in $S$ . We denote a clique with $k$ vertices as a $k$ -clique.

Definition 0.

(Maximal Clique). A clique $G[S]$ is a maximal clique in graph $G$ if and only if $\forall v\in V\setminus S,$ the subgraph induced by $S\cup\{v\}$ is not a clique.

Example 2.

Let us consider the graph shown in Figure 2. The vertices $u_{1},u_{2}$ , and $u_{3}$ induce a 3-clique, but it is not maximal since we can add vertex $u_{4}$ or $u_{5}$ to form a larger 4-clique with the vertices $\{u_{1},u_{2},u_{3},u_{4}\}$ or $\{u_{1},u_{2},u_{3},u_{5}\}$ . The two cliques are maximal because there are no other vertices in the graph that can be included to form a larger clique with these vertices.

Problem Statement. (Maximal Clique Enumeration). Given a graph $G=(V,E)$ , the set of maximal cliques in $G$ is denoted by $mc(G)$ . The task of maximal clique enumeration (shorted as MCE) is to report all the maximal cliques $mc(G)$ .

2.2. Existing Solutions

In the next, we briefly review the state-of-the-art methods for the MCE problem.

BKdegen (Eppstein et al., 2010): Eppstein et al. introduce the degeneracy ordering into MCE before calling the recursive function BKpivot in (Tomita et al., 2006). BKpivot utilizes a pivot selection strategy that selects the vertex $u$ from $X\cup P$ that has the most neighbors in set $P$ , as presented in line 4 in Algorithm 2. This choice ensures that only $u$ and its non-neighbors will be involved in the subsequent search branches. The pivot mechanism divides the search space into two parts, one containing the pivot vertex $u$ and the other without it, thereby avoiding some redundant search branches. As shown in Algorithm 2, the degeneracy order is calculated at the beginning (line 1). Then, for each vertex $v$ , the forbidden set $X$ is initialized as $N^{-}(v)$ , and the candidate set $P$ is initialized as $N^{+}(v)$ (line 3). This ensures that every subproblem starting from $v_{i}$ has a candidate set $P$ whose size is no larger than the degeneracy $\lambda$ . Consequently, the worst-case time complexity is reduced to $O(3^{\frac{\lambda}{3}})$ .

BKrcd (Li et al., 2019b): The subgraph induced by $N^{+}(v)$ may be very dense due to the nature of degeneracy ordering. For a dense subgraph, it only needs to delete a small number of vertices to obtain a maximal clique. As outlined in Algorithm 3, BKrcd uses a top-down search strategy to remove a vertex $v$ with the fewest neighbors in $P$ (line 4) until the remaining vertices in $P$ form a maximal clique (line 3). Then, it calls BKrcd again on the removed vertex $v$ and its neighborhood (line 5). When $P$ is already a clique and passes the maximality check, $P\cup R$ is reported as a maximal clique (lines 8-9). However, not all vertices’ neighborhoods induce a dense subgraph in practice.

Input: Input graph

G

Output: All maximal cliques in

G

1 compute the degeneracy order of the input graph

G

2 for $v\in G$ do

3 BKpivot (

\{v\},N^{+}(v),N^{-}(v)

)

Procedure BKpivot( $R,P,X$ )

4 choose a pivot

u\leftarrow\arg\max_{v\in X\cup P}{N(v)\cap P}

5 for $w\in(P\setminus N(u)\cap P)$ do

6 BKpivot (

R\cup\{w\},P\cap N(w),X\cap N(w)

)

P\leftarrow P\setminus\{w\}

X\leftarrow X\cup\{w\}

Algorithm 2 BKdegen(

G

)

Input: Partial clique

R

, Candidate set

P

, Forbidden set

X

Output: All maximal cliques in

G[P]

restricted by

X

1 if $P=\emptyset$ and $X=\emptyset$ then

2 report

R

as a maximal clique

3while $P$ is not a clique do

v\leftarrow\mathop{\arg\min}_{v\in P}\lvert N(v)\cap P\rvert

5 BKrcd(

R\cup\{v\},P\cap N(v),X\cap N(v)

)

P\leftarrow P\setminus\{v\}

X\leftarrow X\cup\{v\}

8if $P\neq\emptyset$ and $C(P)\cap X=\emptyset$ then

9 report

P\cup R

as a maximal clique

Algorithm 3 BKrcd(

R,P,X

)

3. Reduction-based Framework RMCE

In this subsection, we present a novel reduction-based framework for enumerating maximal cliques.

Reduction-based Maximal Clique Enumeration (shorted as RMCE). The basic idea is to reduce the graph size and recursive search space by removing vertices and edges prior to performing the exhaustive search.

Algorithm 4 depicts the details of the proposed RMCE framework. Initially, we apply the global reduction on the graph $G$ (line 1) before computing its vertex order (line 2). Subsequently, for each vertex in the ascending order of the reduced graph $G$ , we employ the maximality check reduction before entering the recursive function (lines 3-6). The $recursive$ function can be any BK-based algorithm, such as BKpivot and BKrcd. The dynamic reduction is conducted at the beginning of each recursive function (line 7).

Superiority of RMCE. Our reduction algorithm offers two significant advantages. Firstly, it effectively reduces the search branches during the maximal clique enumeration process, leading to a more efficient exploration of the solution space. Secondly, enormous set intersections are involved in the recursive process. RMCE can reduce the number of neighbors for vertices, enabling faster set intersections to enhance time efficiency.

The proposed RMCE consists of three powerful reduction techniques including graph reduction, dynamic reduction, and maximality check reduction.

Input: Graph

G

Output: All maximal cliques in

G

G\leftarrow

apply global reduction on

G

2 compute an order of the reduced graph

G

3 for $i=1:n$ do

v\leftarrow

i

-th vertex in degeneracy order

X\leftarrow

apply maximality check reduction on

X

6 recursive (

R,P,X

)

Procedure recursive( $R,P,X$ )

R,P,X\leftarrow

apply dynamic reduction on

(R,P,X)

8 choose a pivot

u

9 for $w\in(P\setminus N(u)\cap P)$ do

10 recursive (

R\cup\{w\},P\cap N(w),X\cap N(w)

)

P\leftarrow P\setminus\{w\}

X\leftarrow X\cup\{w\}

Algorithm 4 RMCE(

G

)

(1)

Global Reduction: Global reduction means deleting some vertices and edges and reporting their maximal cliques in advance without breaking the completeness of the solution. Formally, if we use $mc(G)$ denote all maximal cliques of a graph $G$ , then we delete some vertices $\Delta V$ and edges $\Delta E$ such that

$mc(G)=mc(G^{\prime})+\alpha(\Delta V,\Delta E),$

where $G^{\prime}=(V\setminus\Delta V,E\setminus\Delta E)$ , where $\alpha(\Delta V,\Delta E)$ denote the maximal cliques that contain vertices in $\Delta V$ or edges in $\Delta E$ . This reduction technique significantly reduces the scale of the input graph, enhancing the efficiency of subsequent computations.
(2)

Dynamic Reduction: The RMCE framework finds the maximal cliques by using a recursive search in which subproblems will be built dynamically.

Definition 0.

(Subproblem). In algorithms following the BK framework, a subproblem is represented by a partial clique $R$ , a candidate set $P$ , and a forbidden set $X$ , denoted as $(R,P,X)$ . The maximal cliques in this subproblem are denoted by $\tilde{mc}(R,P,X)$ .

During the recursive search, the subproblem undergoes continuous changes, providing opportunities for vertices that cannot be pruned globally to be pruned within the subproblem dynamically. This brings the need for dynamic reduction.

Formally, we delete some vertices $\Delta P_{1}$ from the candidate set and move some vertices $\Delta P_{2}$ into $R$ such that

$\tilde{mc}(R,P,X)=\tilde{mc}(R^{\prime},P^{\prime},X^{\prime})+\tilde{\alpha}(R,\Delta P_{1},X),$

where $R^{\prime}=R\cup\Delta P_{2}$ , $P^{\prime}=P\setminus(\Delta P_{1}\cup\Delta P_{2})$ , $X^{\prime}=X\cap\Delta P_{2}$ , and $\tilde{\alpha}(R,\Delta P_{1},X)$ denotes the maximal cliques that contain $R$ and vertices in $\Delta P_{1}$ in the subproblem $(R,P,X)$ . This technique further reduces the size of the subproblem, efficiently minimizing the search space required for the subsequent search.
(3)

Maximality Check Reduction: Maximality check reduction refers to reducing the size of forbidden set $X$ without producing any cliques that are not maximal or losing any maximal cliques, that is

$\tilde{mc}(R,P,X)=\tilde{mc}(R,P,X\setminus\Delta X),$

where $\Delta X$ denotes the deleted vertices from the forbidden set. This reduction technique prunes unnecessary computations by identifying and eliminating vertices that can be safely ignored during the maximality check process.

Our framework efficiently reduces both the graph size and the recursive search space. Meanwhile, the reduction itself is expected to take as little time as possible. To achieve this, we carefully develop reduction rules to ensure that they do not introduce excessive extra computation. Next, we will delve into the detailed design and advantages of each of these potent reduction techniques.

4. Global Reduction

4.1. Intuition

Degeneracy order, proposed by Eppstein et al. (2010), has been widely employed as the preferred vertex ordering technique in the maximal clique enumeration task. Nonetheless, we argue that degeneracy order suffers from two major problems:

(1)

Redundant computations for low-degree vertices: When generating the degeneracy order, the iterative removal of vertices with the minimum degree is necessary. In fact, identifying maximal cliques containing low-degree vertices is straightforward due to their inherent simplicity. However, these vertices and their associated edges will be redundantly traversed during subsequent recursions of the MCE algorithm. This redundancy is expected to be mitigated through an effective reduction technique.
(2)

Redundant computations for edges: In addition to low-degree vertices, certain edges also undergo repetitive traversals. This is particularly evident for edges that do not form triangles with other edges in high-degree vertices. The redundant computations associated with these edges can be minimized through appropriate techniques.

We propose two kinds of reduction techniques, namely Low-degree Vertex Reduction (Section 4.2) and Non-triangle Edge Reduction (Section 4.3), to effectively tackle these challenges. Our reduction methods ensure that all deleted edges and vertices are not necessary to be considered in subsequent processes, allowing the MCE algorithm to operate on the reduced graph.

4.2. Low-Degree Vertex Reduction

In this subsection, we introduce an efficient graph reduction technique by eliminating vertices with a degree no larger than 2. We present three reduction rules, each handling vertices of degree zero, one, and two, respectively.

Lemma 1.

(Degree-Zero Reduction) A vertex $u$ with a degree of 0 can be removed from $G$ such that $mc(G)=mc(G^{\prime})$ where $G^{\prime}=(V\setminus\{u\},E)$ .

Proof.

The proof is straightforward since a clique contains at least two vertices. ∎

Lemma 2.

(Degree-One Reduction) Let $u$ be a degree-one vertex with the only neighbor $v$ . The vertex $u$ and its adjacent edge can be removed such that $\lvert mc(G)\rvert=\lvert mc(G^{\prime})\rvert+1$ , where $G^{\prime}=(V\setminus\{u\},E\setminus\{(u,v)\})$ .

Proof.

The vertex set $\{u,v\}$ forms a 2-clique by definition, and $N(v)\cap N(u)=\emptyset$ ensures its maximality. ∎

Lemma 3.

(Degree-Two Reduction) For a degree-two vertex $u$ with neighbors $v$ and $w$ , we have the following scenarios:

(1)

If $(v,w)\notin E$ , the edges $(u,v)$ and $(u,w)$ are two maximal $2$ -cliques. $u$ and its edges can be deleted such that $\lvert mc(G)\rvert=\lvert mc(G^{\prime})\rvert+2$ , where $G^{\prime}=(V\setminus\{u\},E\setminus\{(u,v),(u,w)\})$ .
(2)

If $(v,w)\in E$ and $N(v)\cap N(w)=\emptyset$ , the three edges $(u,v)$ , $(u,w)$ , and $(v,w)$ form a maximal $3$ -clique. Vertex $u$ and the three edges can be safely deleted such that $\lvert mc(G)\rvert=\lvert mc(G^{\prime})\rvert+1$ , where $G^{\prime}=(V\setminus\{u\},E\setminus\{(u,v),(u,w),(v,w)\})$ .
(3)

If $(v,w)\in E$ and $N(v)\cap N(w)\neq\emptyset$ , the three edges $(u,v)$ , $(u,w)$ , and $(v,w)$ form a maximal $3$ -clique. Vertex $u$ and two edges $(u,v)$ and $(u,w)$ can be safely deleted such that $\lvert mc(G)\rvert=\lvert mc(G^{\prime})\rvert+1$ , where $G^{\prime}=(V\setminus\{u\},E\setminus\{(u,v),(u,w)\})$ .

Proof.

For the first condition, $N(u)\cap N(v)=\emptyset$ means $\{u,v\}$ forms a maximal 2-clique. Since $\nexists u^{\prime}\in V,N(u^{\prime})\supseteq\{u,v\}$ , edge $(u,v)$ can be deleted. And edge $(u,w)$ is similar to $(u,v)$ . When $(v,w)\in E$ , the edges $(u,v)$ , $(u,w)$ , and $(v,w)$ form a maximal 3-clique since $N(u)\cap N(v)\cap N(w)=\emptyset$ . In the second scenario, $N(v)\cap N(w)=\emptyset$ , ensuring that $\{v,w\}$ cannot be enlarged, which requires the deletion of $(u,v)$ to avoid reporting it as a maximal 2-clique again. Otherwise, it implies that $\exists S\subseteq V,S\cup\{v,w\}$ is also a maximal clique, indicating that the edge $(v,w)$ cannot be deleted. ∎

Example 3.

Consider the graph presented in Figure 3. Vertices $v_{1},v_{2},v_{3}$ , and $v_{6}$ can be deleted by our degree-two Reduction. The vertices $v_{7}$ and $v_{8}$ can be deleted by our degree-one Reduction.

Algorithm 5 provides an overview of the VertexReduction procedure. First, a set $Q$ is initialized with all vertices whose degree is at most 2 (line 1). Then, for each vertex $v$ in $Q$ , we apply either degree-two reduction, degree-one reduction, or degree-zero reduction based on its degree (lines 4-6, 10-13, 16-17). We also update $Q$ whenever a new vertex with a degree of no larger than 2 is encountered (lines 7-10, 14-15).

Input: Graph

G

Output: Reduced graph

G^{\prime}

G^{\prime}\leftarrow G

Q\leftarrow\{v\mid d_{G}(v)\leq 2\}

2for $v\in Q$ do

Q\leftarrow Q\setminus\{v\}

4 if $d_{G^{\prime}}(v)=2$ then

u,w\leftarrow

the remaining two neighbors of

v

G^{\prime}\leftarrow

apply the degree-two reduction rule on

v

7if $u\notin Q$ and $d_{G^{\prime}}(u)\leq 2$ then

Q\leftarrow Q\cup\{u\}

9if $w\notin Q$ and $d_{G^{\prime}}(w)\leq 2$ then

Q\leftarrow Q\cup\{w\}

11 else if $d_{G^{\prime}}(v)=1$ then

u\leftarrow

the only neighbor of

v

G^{\prime}\leftarrow

apply the degree-one reduction rule on

v

14 if $u\notin Q$ and $d_{G^{\prime}}(u)\leq 2$ then

Q\leftarrow Q\cup\{u\}

16 else

G^{\prime}\leftarrow

apply the degree-zero reduction rule on

v

18return

G^{\prime}

Algorithm 5 VertexReduction(

G

)

Complexity Analysis. Algorithm 5 examines a total of $n$ vertices. Checking the existence of a common neighbor in degree-two reduction has a worst-case time complexity of $O(2d_{max})$ by merge-based algorithm (Zheng et al., 2021), where $d_{max}$ is the maximum degree in graph $G$ . Hence, the overall time complexity is $O(nd_{max})$ . The space cost of $O(n)$ is required to maintain the vertices that need to be removed.

Algorithm 5 demonstrates superior practical performance due to several factors. Firstly, it considers vertices with a degree less than or equal to two, reducing the number of vertices to be processed. Secondly, for degree-zero and degree-one reductions, the algorithm operates in linear time, making the reduction efficient. Lastly, degree-two reduction involves finding a common neighbor between two vertices $v$ and $w$ , rather than computing all the common neighbors, which runs very fast in practice.

4.3. Non-triangle Edge Reduction

Apart from the vertex-based reduction technique, we also propose another reduction approach from the perspective of edges, namely non-triangle edge reduction.

Definition 0.

(Non-triangle Edge). Edge $(u,v)$ is defined as a non-triangle edge if $N(v)\cap N(u)=\emptyset$ .

A non-triangle edge $(u,v)$ means no other vertex in the graph is adjacent to both $u$ and $v$ . The objective is to remove all non-triangle edges from the graph, guaranteed by the following lemma.

Lemma 4.

(Non-triangle Edge Reduction) A non-triangle edge $(u,v)$ directly forms a maximal $2$ -clique and it can be deleted from $G$ such that $\lvert mc(G)\rvert=\lvert mc(G^{\prime})\rvert+1$ , where $G^{\prime}=(V,E\setminus\{(u,v)\})$ .

Proof.

It is straightforward that set $\{u,v\}$ cannot be expanded by including any other vertex, because adding any vertex into it will break the property of clique. ∎

Input: Graph

G=(V,E)

Output: Reduced graph

G^{\prime}

G^{\prime}\leftarrow

2 for $(u,v)\in E$ do

3 if $(u,v)$ is not visited then

4 if $u$ and $v$ has no common neighbors then

G^{\prime}\leftarrow

delete the edge

(u,v)

from

G^{\prime}

6 report

\{u,v\}

as a maximal clique

else

w\leftarrow

a common neighbor of

u

and

v

8 mark edges

(u,v),(u,w)

, and

(v,w)

visited

9return

G^{\prime}

Algorithm 6 EdgeReduction(

G

)

Algorithm 6 systematically examines each edge in the graph $G$ to determine whether it can be removed. Initially, for an unvisited edge $(u,v)$ , if $u$ and $v$ have no common neighbors (line 4), the edge $(u,v)$ is classified as a non-triangle edge, and we can delete it while reporting $\{u,v\}$ as a maximal clique (lines 5-6). Conversely, if a vertex $w$ is their common neighbor, we mark the three edges $(u,v)$ , $(u,w)$ , and $(v,w)$ as visited, since they form a 3-clique (lines 7-8). Once an edge is marked as visited, it prevents the need for redundant checks on that edge in the future (line 3).

Example 4.

Consider the graph depicted in Figure 3. The edges represented by orange dashed lines (e.g., $(u_{1},v_{3})$ and $(v_{4},u_{5})$ ) are identified as non-triangle edges and can be safely deleted from the graph. Note that after deleting edges $(u_{4},v_{5})$ and $(v_{5},u_{8})$ , vertex $v_{5}$ becomes a new degree-two vertex and can be removed by degree-two reduction.

Figure 4 showcases a representative search tree for the graph presented in Figure 3. By utilizing the graph reduction method, we avoid traversing the paths marked in red, resulting in a notable reduction in computational cost. Furthermore, even along the remaining black search paths, the set intersection operations can be accelerated due to the decreased neighborhood size for multiple vertices.

Complexity Analysis. Algorithm 6 examines a total of $m$ edges. Moreover, finding a common neighbor takes a worst-case time complexity of $O(2d_{max})$ . Consequently, the overall time complexity of EdgeReduction is $O(md_{max})$ . The space overhead of recording the visited edges is $O(m)$ . Notably, Algorithm 6 is considerably faster in practice due to two reasons: Firstly, once a triangle is encountered, three edges no longer require further examination. Secondly, for the majority of edges, finding a common neighbor between the two vertices only needs to identify a single vertex, resulting in a small probability of reaching worst-case time complexity.

5. Dynamic Reduction

5.1. Intuition

As discussed above, global reduction directly applies to the input graph $G$ . Beyond that, the recursive procedure of the MCE program will explore numerous subgraphs, presenting opportunities for further reducing the redundant computations. Let us consider the following example.

Example 5.

Figure 5(a) depicts a subgraph involved in a subproblem, where all vertices are adjacent to the current partial clique $R$ . The vertices marked in blue form the forbidden set $X$ , which is utilized for maximality checks, while the orange vertices represent the candidate set $P$ . The corresponding recursion tree for this subproblem is displayed in Figure 6(a). By scrutinizing the recursion tree, we make the following key observations:
(1) New low-degree vertices (e.g., $u_{7}$ , $u_{8}$ , and $u_{9}$ ) appear in this subproblem and can be effectively handled similar to the global scenario, without creating additional recursion or performing set intersection operations.
(2) As presented in Figure 6(a), there are no other branches from $u_{1}$ to $u_{6}$ in the search path $R\rightarrow u_{3}\rightarrow u_{1}\rightarrow u_{2}\rightarrow u_{6}$ . Because vertices $u_{1}$ , $u_{2}$ , and $u_{6}$ connect to all other vertices in $P\cap\{u_{3}\}$ in the subproblem $(R\cup\{u_{3}\},P\cap\{u_{3}\},X\cap\{u_{3}\})$ , we can move $u_{1}$ , $u_{2}$ , and $u_{6}$ into partial clique $R\cup\{u_{3}\}$ together instead of creating three additional recursive calls. Clearly, this will further reduce the computation cost.

Building upon these observations, we propose a dynamic reduction technique aimed at further decreasing the size of subproblems at the recursion level.

5.2. Dynamic Vertex Reduction

Dynamic reduction is designed for reducing the subgraph size of subproblem $(R,P,X)$ . Different from global reduction, the maximal cliques in subgraph $G[P]$ may not be maximal in the graph $G$ , because there may exist a vertex in the forbidden set $X$ that can be used to expand the maximal cliques in $G[P]$ . To address this, we develop dynamic reduction techniques tailored specifically for degree-zero, degree-one, and degree- $(\lvert P\rvert-1)$ vertices. These techniques effectively optimize the search process while ensuring that only truly maximal cliques are reported.

For ease of presentation, a vertex $v$ is called a dynamic degree- $k$ vertex in the subproblem $(R,P,X)$ if $\lvert N_{P}(v)\rvert=k$ .

Lemma 5.

(Dynamic Degree-Zero Reduction) For a dynamic degree-zero vertex $u\in P$ in the subproblem $(R,P,X)$ , we have

(1)

If $N(u)\cap X=\emptyset$ , $R\cup\{u\}$ is a maximal clique. Thus, we can remove $u$ from $P$ , and $\lvert\tilde{mc}(R,P,X)\rvert=\lvert\tilde{mc}(R,P^{\prime},X)\rvert+1$ , where $P^{\prime}=P\setminus\{u\}$ .
(2)

If $N(u)\cap X\neq\emptyset$ , $R\cup\{u\}$ is not maximal. Thus, we can remove $u$ from $P$ and $\tilde{mc}(R,P,X)=\tilde{mc}(R,P^{\prime},X)$ , where $P^{\prime}=P\setminus\{u\}$ .

Proof.

For the dynamic degree-zero vertex $u$ , we have $u\in P$ , which guarantees the clique property. When $N(u)\cap X=\emptyset$ , it indicates that $R\cup\{u\}$ is maximal since $N_{P}(u)=\emptyset$ , which proves the first condition. Otherwise, adding $u$ into $R$ will produce a non-empty forbidden set $X$ , making $R\cup\{u\}$ not maximal. Thus, $u$ can be removed from $P$ . ∎

Lemma 6.

(Dynamic Degree-One Reduction) Consider a dynamic degree-one vertex $u\in P$ with its only neighbor $v\in P$ in the subproblem $(R,P,X)$ . There are two scenarios:

(1)

If $\exists w\in X$ such that $u,v\in N(w)$ , vertex $u$ can be immediately removed such that $\tilde{mc}(R,P,X)=\tilde{mc}(R,P^{\prime},X)$ where $P^{\prime}=P\setminus\{u\}$ . If $v$ is also a dynamic degree-one vertex before $u$ ’s removal, then $v$ should also be removed, that is $\tilde{mc}(R,P,X)=\tilde{mc}(R,P\setminus\{u,v\},X)$ .
(2)

If $\nexists w\in X$ such that $u,v\in N(w)$ , $R\cup\{u,v\}$ is a maximal clique and vertex $u$ is deleted such that $\lvert\tilde{mc}(R,P,X)\rvert=\lvert\tilde{mc}(R,P^{\prime},X)\rvert+1$ where $P^{\prime}=P\setminus\{u\}$ . If $v$ is also a dynamic degree-one vertex before $u$ ’s removal, then $v$ should be removed as well, that is $\lvert\tilde{mc}(R,P,X)\rvert=\lvert\tilde{mc}(R,P\setminus\{u,v\},X)\rvert+1$ .

Proof.

If $\exists w\in X$ such that $u,v\in N(w)$ , moving $\{u,v\}$ into $R$ would result in an empty $P$ but non-empty $X$ , as $w\in X$ . This indicates a non-maximal clique. Otherwise, $X$ will be empty after the intersection, signifying the discovery of a maximal clique. $v$ will become a dynamic degree-zero vertex if it is a dynamic-one vertex before. It needs to be removed because $N(u)\supseteq R\cup\{v\}$ indicates that $v$ cannot form a maximal clique in the subproblem $(R,P\setminus\{u\},X)$ . ∎

In Lemma 6, for each dynamic degree-one vertex $u\in P$ in the subproblem, we need to determine whether $u$ and $v$ share a common vertex in the forbidden set $X$ . Thus, the overall time cost is $O((\lvert X\rvert+d_{max})\lvert P\rvert)$ . Since the reduction is expected to introduce as little extra computation cost as possible, we develop a relaxed version of dynamic degree-one reduction as follows.

Lemma 7.

(Relaxed Dynamic Degree-One Reduction) Consider a dynamic degree-one vertex $u\in P$ with its only neighbor $v\in P$ in the subproblem $(R,P,X)$ . If $N(u)\cap X=\emptyset$ or $N(v)\cap X=\emptyset$ , $R\cup\{v,u\}$ forms a maximal clique and vertex $u$ can be removed from $P$ such that $\lvert\tilde{mc}(R,P,X)\rvert=\lvert\tilde{mc}(R,P^{\prime},X)\rvert+1$ where $P^{\prime}=P\setminus\{u\}$ . If $v$ is also a dynamic degree-one vertex before $u$ ’s removal, $v$ will be removed as well, that is $\lvert\tilde{mc}(R,P,X)\rvert=\lvert\tilde{mc}(R,P\setminus\{u,v\},X)\rvert+1$ .

Proof.

If $N(v)\cap X=\emptyset$ or $N(u)\cap X=\emptyset$ , it implies that $\nexists w\in X$ such that $v,u\in N(w)$ . Therefore, we can deduce the conclusion using Lemma 6. ∎

Input: Partial clique

R

, Candidate set

P

, Forbidden set

X

Output: Reduced

R^{\prime},P^{\prime},X^{\prime}

R^{\prime},P^{\prime},X^{\prime}\leftarrow R,P,X

2 for $v\in X$ do

3 for $u\in N_{P}(v)$ do

4 mark

u

5for $v\in P$ do

6 if $d_{P}(v)=0$ then

P^{\prime}\leftarrow

apply the dynamic degree-zero reduction rule on

v

8else if $d_{P}(v)=1$ then

u\leftarrow

v

’s only neighbor

10 if $v$ is not marked or $u$ is not marked then

P^{\prime}\leftarrow

apply the relaxed dynamic degree-one reduction rule on

v

12for $v\in P^{\prime}$ do

13 if $d_{P^{\prime}}(v)=\lvert P^{\prime}\rvert-1$ then

P^{\prime},R^{\prime}\leftarrow

apply the dynamic degree-

(\lvert P\rvert-1)

reduction rule on

v

/* Update the forbidden set

X

X^{\prime}\leftarrow X\cap N(R^{\prime})

16return

R^{\prime},P^{\prime},X^{\prime}

Algorithm 7 dynamicVertexReduction(

R,P,X

)

Note that the cost of conducting this reduction rule is trivial since we can efficiently maintain $N(v)\cap X$ by traversing the neighbors of each vertex in the forbidden set $X$ just once. Subsequently, applying Lemma 7 on dynamic degree-one vertices only requires traversing the candidate set $P$ . The overall time complexity for this process is $O(\lvert X\rvert\lvert P\rvert)$ .

Example 6.

Let us consider the subproblem presented in Figure 5(a). The vertices in the candidate set $P$ are in orange color and the forbidden set $X$ consists of vertices in blue color. Through the reduction rules, we can safely remove the dynamic degree-zero vertices $u_{9}$ and $u_{11}$ , resulting in the new subgraph of the subproblem shown in Figure 5(b). Additionally, removing the degree-one vertices $u_{7}$ , $u_{8}$ , and $u_{10}$ leads to the subgraph of this subproblem in Figure 5(c).

Lemma 8.

(Dynamic Degree- $(\lvert P\rvert-1)$ Reduction) If a vertex $u\in P$ satisfies $\lvert N_{P}(u)\rvert=\lvert P\rvert-1$ in the subproblem $(R,P,X)$ , $u$ is called a dynamic degree- $(\lvert P\rvert-1)$ vertex. In this case, we can directly move $u$ from $P$ into $R$ , ensuring that $\tilde{mc}(R,P,X)=\tilde{mc}(R^{\prime},P^{\prime},X^{\prime})$ , where $R^{\prime}=R\cup\{u\}$ , $P^{\prime}=P\setminus\{u\}$ , and $X^{\prime}=X\cap N(u)$ .

Proof.

For a dynamic degree- $(\lvert P\rvert-1)$ vertex $u$ , we have $\lvert N_{P}(u)\rvert=\lvert P\rvert-1$ , which means $\forall S\subseteq P$ and $u\notin S$ , $u\in C(S)$ . Assume there exists a subset $S\subseteq P$ that $u\notin S$ and $S\cup R$ is a clique. Then $S\cup R$ is not maximal due to $u\in P\cap C(S)$ . That is any maximal clique in the subproblem $(R,P,X)$ must contain the vertex $u$ .

∎

Example 7.

Let us revisit the subproblem presented in Figure 5(a). Based on the updated subgraph in Figure 5(c), we identify that vertices $u_{1}$ , $u_{2}$ , $u_{3}$ , and $u_{6}$ are all dynamic degree- $(\lvert P\rvert-1)$ vertices. As a consequence, adding these vertices to $R$ will make the subgraph of this subproblem much smaller, with only two isolated vertices, as shown in Figure 5(d). Hence, the overall search tree of this subproblem derived from our reduction rule is shown in Figure 6(b). It is noteworthy that the dynamic degree-zero and degree-one reductions effectively eliminate low-degree vertices from the original subproblem, thereby enhancing the efficiency of dynamic degree- $(\lvert P\rvert-1)$ reduction and further reducing the scale of the subproblem.

Algorithm 7 outlines our dynamic reduction procedure in detail. It starts by marking each neighbor $u$ of each vertex $v$ in forbidden set $X$ if $u\in P$ , where a marked vertex $u$ means $N(u)\cap X\neq\emptyset$ (lines 2-4). Subsequently, we iterate through each vertex $v\in P$ . For dynamic degree-zero vertices, we remove them according to Lemma 5 (lines 6-7). For dynamic degree-one vertices, we selectively remove some of them following the relaxed dynamic degree-one reduction rule in Lemma 7 (lines 8-11). Afterward, we reiterate through reduced $P^{\prime}$ again to perform the dynamic degree- $(\lvert P\rvert-1)$ reduction (lines 12-14). Once all reduction operations are completed, we update the forbidden set $X$ so that $R^{\prime}\subseteq N(X^{\prime})$ (line 15).

Complexity Analysis. Marking the vertices in $P$ takes the cost $O(\lambda\lvert X\rvert)$ (lines 2-4), where $\lambda$ is the degeneracy of the graph $G$ . Traversing the vertices in $P$ and their neighbors costs $O(\lambda\lvert P\rvert)$ . Updating the set $X$ also requires $O(\lambda\lvert X\rvert)$ time. Thus, the overall time cost of Algorithm 7 is $O(\lambda(\lvert X\rvert+\lvert P\rvert))$ in the worst case. The space overhead is $O(\lvert P\rvert)$ as we need to mark the vertices in $P$ .

Discussion. Let us consider the search trees in Figure 6, there are 5 search nodes that need to conduct a pivot selection (excluding leaf nodes) in Figure 6(a). The time overhead is $O(5(|P|+|X|)^{2})$ . By performing dynamic reduction techniques (explained in Example 7), we reduce the number of nodes that need to conduct a pivot selection from 5 to 1, as shown in Figure 6(b). In other words, the speedups of this procedure achieve 5 $\times$ . In practice, such situations may occur frequently during the search process, improving the time efficiency significantly.

6. Maximality Check Reduction

6.1. Intuition

In order to enhance the time efficiency, considerable effort has been focused on reducing the candidate set $P$ , while the cost of the maximality check has often been overlooked. In this section, we shed light on the observation that the forbidden set $X$ entails a significant amount of redundant computation. To address this issue, we introduce a technique namely, maximality check reduction, that efficiently reduces the forbidden set $X$ .

6.2. Forbidden Set Reduction

The insight above leads to a method of reducing the forbidden set $X$ by checking the neighborhood dominance between vertices in $X$ , as presented in the following Lemma.

Lemma 9.

(Forbidden Set Reduction by Neighbor Containment) For two vertices $u,v\in X$ , if $N_{P}(u)\subseteq N_{P}(v)$ , it holds that $\tilde{mc}(R,P,X)=\tilde{mc}(R,P,X^{\prime})$ , where $X^{\prime}=X\setminus\{u\}$ .

Proof.

In the subproblem $(R,P,X)$ , assume a non-maximal clique $R\cup\Delta R$ becomes maximal due to the removal of $u$ where $\Delta R\subseteq P$ , which means $\Delta R\subseteq N_{P}(u)$ . The maximality $X\cap C(\Delta R)=\emptyset$ implies that $\Delta R\supseteq N_{P}(v)$ , which contradicts the condition $N_{P}(u)\subseteq N_{P}(v)$ . Thus, the Lemma 9 holds. ∎

Example 8.

Consider the graph shown in Figure 5(a). We observe that $N_{P}(v_{1})=\{u_{1},u_{7}\}$ , $N_{P}(v_{3})=\{u_{1},u_{2},u_{3}\}$ , and $N_{P}(v_{4})=\{u_{9}\}$ are subsets of $N_{P}(v_{2})=\{u_{1},u_{2},u_{3},u_{7},u_{9}\}$ . If we remove vertices $v_{1}$ , $v_{3}$ , and $v_{4}$ from the forbidden set $X$ , the solution of the current subproblem will remain unaffected, that is, any cliques that are not maximal will not be reported and any maximal cliques will not be lost. For example, $R\cup\{u_{9}\}$ is not a maximal clique due to the adjacent relationship with vertices $v_{4}$ and $v_{2}$ . After removing $v_{4}$ from the forbidden set, the clique $R\cup\{u_{9}\}$ will not be maximal due to the existence of vertex $v_{2}$ .

Establishing the neighbor containment relationship between vertices in $X$ by traversing them and their neighbors in each subtask incurs significant time overhead. Therefore, we design an efficient approach that continuously establishes the neighbor containment relationship between vertices during the MCE process, allowing us to prune the $X$ set without incurring additional time overhead. The overall process is outlined in Algorithm 8.

Input: Vertex

v

inducing the subproblem with partial clique

\{v\}

, candidate set

P

, and forbidden set

X

; an array

ignoreId

Output: Reduced

X^{\prime}

X^{\prime}\leftarrow X

/* reduce

X

for current subgraph */

i\leftarrow

the order of vertex

v

in ascending order

3 for $u\in X$ do

4 if $ignoreId[u]<i$ then

X^{\prime}\leftarrow X^{\prime}\setminus\{u\}

/* update

ignoreId

6 for $u\in P$ do

7 if $P\subseteq N^{+}(u)$ then

j\leftarrow

the order of

u

ignoreId[v]\leftarrow\min(j,ignoreId[v])

10else if $N^{+}(u)\subseteq P$ then

ignoreId[u]\leftarrow\min(i,ignoreId[u])

12return

X^{\prime}

Algorithm 8 forbiddenSetReduction(

v,P,X,ignoreId

)

A subproblem induced by vertex $v$ refers to the subproblem with partial clique $R=\{v\}$ , candidate set $P=N^{+}(v)$ , and forbidden set $X=N^{-}(v)$ . Algorithm 8 aims to establish a neighbor containment relationship between $v$ and vertices in the candidate set $P$ of the induced subproblem by vertex $v$ , and efficiently prunes the $X$ set. It utilizes an array of size $n$ , called $ignoreId$ , to record the order in which vertices can be excluded from constructing the set $X$ . Initially, all elements are set to $n$ , indicating that no vertex will be ignored. For a subgraph induced by the later neighbors of a vertex $v$ , if a candidate vertex $u$ satisfies $P\subseteq N^{+}(u)$ , i.e., $N^{+}(v)\subseteq N^{+}(u)$ , then $v$ can be ignored in all subsequent subproblems after completing the $j$ -th iteration, where $j$ is the order of $u$ . This is because in any subproblem after that, if $v\in X$ , then $u$ must be contained in $X$ , which allows us to prune $v$ following Lemma 9. Thus, the $ignoreId$ of vertex $v$ will be updated as the minimum of $j$ and its current value (lines 7-9). Conversely, if $N^{+}(u)\subseteq P$ , it means $u$ can be ignored instantly after this iteration since $N_{P}(u)$ will be dominated by $N_{P}(v)$ in all subsequent subproblems (lines 10-11).

Complexity Analysis. Reducing the size of the forbidden set $X$ runs in $O(\lvert X\rvert)$ , which is linear in the size of $X$ . The process of updating $ignoreId$ for each vertex in $P$ involves traversing their later neighbors. Thus, the time complexity of Algorithm 8 is $O(\lambda\lvert P\rvert)$ . The space complexity is $O(n)$ due to the array ignoreId of size $n$ .

7. Experiments

7.1. Experimental Setting

Table 2. Graph Statistics, where

\lambda

represents the degeneracy.

Graph	Abbr.	#Vertices	#Edges	$d_{max}$	$\lambda$
as-skitter	as	1696415	11095298	35455	111
ca-CondMat	ca	23133	93439	279	25
cit-Patents	cp	3774768	16518947	793	64
com-dblp	cd	317080	1049866	343	113
com-orkut	co	3072441	117185083	33313	253
com-youtube	cy	1134890	2987624	28754	51
email-EuAll	ee	265009	364481	7636	37
flickr	fl	105938	2316948	5425	573
inf-road-usa	in	23947346	28854311	9	3
large_twitch	lt	168114	6797557	35279	149
loc-gowalla	lg	196591	950327	14730	51
roadNet-CA	rc	1965206	2766607	12	3
sc-delaunay_n23	sd	8388608	25165784	28	4
soc-pokec	sp	1632803	22301964	14854	47
soc-twitter-higgs	st	456631	12508440	51386	125
web-Google	wg	875713	4322051	6332	44
web-Stanford	ws	281903	1992636	38625	71
wiki-Talk	wt	2394385	4659565	100029	131

Dataset. As listed in Table 2, we use 18 real networks from SNAP (Leskovec and Krevl, 2014) and Network Repository (Rossi and Ahmed, 2015) in the experiments.

Algorithms. We evaluate the performance of enhancing four existing methods BKdegen, BKrcd, BKfacen, and BKrevised.

•

BKdegen (Eppstein et al., 2010): The degeneracy-based algorithm.
•

BKrcd (Li et al., 2019b): The top-down algorithm for MCE.
•

BKfacen (Jin et al., 2022): MCE algorithm that uses hybrid data structure with adjacency list and partial adjacency matrix.
•

BKrevised (Naudé, 2016): MCE algorithm with a revised pivot selection strategy.
•

RMCEdegen: Our method uses the recursion of BKdegen.
•

RMCErcd: Our method uses the recursion of BKrcd.
•

RMCEfacen: Our method uses the recursion of BKfacen.
•

RMCErevised: Our method uses the recursion of BKrevised.

All experiments are conducted on a Linux Server equipped with Intel(R) Xeon(R) CPU E5-2696 v4 @ 2.20GHz and 128G RAM. All algorithms are implemented in C++ and compiled with - $O3$ option. The source code of RMCE is available at https://github.com/DengWen0425/RMCE.

7.2. Overall Result

Taking the running time cost of each original MCE algorithm as the baseline, we compute the speedups of our methods over BKdegen, BKrcd, BKfacen, and BKrevised, respectively. Figure 7 presents the results for 18 graphs. we can observe that RMCEdegen and RMCErcd consistently outperform both BKdegen and BKrcd. Specifically, RMCEdegen achieves a maximum speedup of 4.29 $\times$ in the inf-road-usa dataset, RMCErcd achieves a maximum speedup of 3.77 $\times$ in the flickr dataset, RMCEfacen achieves a maximum speedup of 44.7 $\times$ in the web-standford dataset, and RMCErevised achieves a maximum speedup of 26.8 $\times$ in the large_twitch dataset. The experimental results confirm that our proposed reduction methods demonstrate considerable performance in accelerating the MCE procedure.

7.3. Detailed Evaluation

The Effect of Global Reduction. To evaluate the effect of our global reduction, we show the ratio of deleted vertices and the ratio of deleted edges compared to the original graph in Figure 8. We can find that over 35% vertices in 12 graphs (e.g., as-Skitter, cit-Patents, and com-youtube) can be removed by using the global reduction. Beyond that, over 20% edges in 9 graphs (e.g., email-EuAll, loc-gowalla, and wiki-Talk) can be removed. In particular, all vertices and edges in graphs inf-road-usa and roadNet-CA have been deleted due to their sparsity (thus, we can exclude them from subsequent experiments). It is worth noting that no vertices and edges in the sc-delaunay_n23 dataset have been deleted, which also verifies the effectiveness of our other reduction methods, i.e., dynamic reduction and maximality check reduction, on the other hand.

Number of Recursive Calls. In this experiment, we investigate the number of recursive calls during the MCE algorithm to demonstrate the pruning power of our reduction method. We evaluate the reduction ability of three algorithms by comparing their recursive calls to that of the baseline BKdegen. Formally, we define the ratio of recursive calls as

\frac{\#\text{recursive calls of a method (like RMCEdegen) }}{\#\text{recursive calls of original algorithm (like BKdegen)}}

As depicted in Figure 9, RMCEdegen can reduce the number of recursive calls to no more than 17.6%, RMCErcd can reduce the number of recursive calls to no more than 28.5%, the number of recursive calls of RMCEfacen are all below 4.5% of original, and for RMCErevised, the ratios of the number of recursive calls are no more than 20.5%. In specific instances, such as inf-road-usa and roadNet-CA, no recursive calls are required since all the vertices and edges have been removed by utilizing the global reduction. The ratio of the number of recursive calls serves as an indicator of the effectiveness of a method, as each recursive call typically involves set intersection and pivot selection. The superior pruning ability of our algorithms is evident from these results.

Effect of Forbidden Set Reduction. To evaluate the impact of our forbidden set reduction, we examine two key metrics: the ratio of pruned vertices when constructing the forbidden set $X$ for each subproblem ( $r_{vertex}=\frac{\sum\lvert X^{\prime}\rvert}{\sum\lvert X\rvert}$ ) and the ratio of subproblems where forbidden set reduction occurs ( $r_{subproblem}=\frac{\#\{subproblem\mid X^{\prime}\subset X\}}{\#subproblem}$ ) in the outer iteration. The results are depicted in Figure 10.

Remarkably, we observe that in datasets such as ca-CondMat, com-dblp, web-Google, and web-Stanford, the ratio of pruned vertices (i.e., $r_{vertex}$ ) can reach close to 50%. Additionally, in datasets like ca-CondMat, com-dblp, flickr, and sc-delaunay_n23, the ratio of reduced subproblems ( $r_{subproblem}$ ) achieves nearly 40%, indicating the significant pruning effect of our maximality check reduction technique on the size of the forbidden set $X$ . These results highlight the effectiveness of our method in reducing the computational overhead of the maximality check process.

Reduction of Vertex Visits. We also report the distribution of vertex visits with respect to their degrees. Due to space limitations, we report the results of 4 graphs including web-Google, cit-Patents, soc-pokec, and com-dblp. As illustrated in Figure 11, our method RMCEdegen yields a substantial reduction in the number of vertex visits across different degrees. In web-Google ((Figure 11(a)), RMCEdegen reduces 88% vertex visits compared to BKdegen (70% compared to BKrcd) at degree 20. In cit-Patents (Figure 11(b)), RMCEdegen reduces 82% vertex visits compared to BKdegen (82% compared to BKrcd) at degree 15. And in com-dblp (Figure 11(d)), RMCEdegen reduces 73% vertex visits compared to BKdegen (61% compared to BKrcd) at degree 3. These results confirm the effectiveness of global reduction.

While for graphs that contain many vertices with a higher degree such as soc-pokec in Figure 11(c), our method not only decreases the visits of low-degree vertices but also reduces the visits of high-degree vertices. For example, RMCEdegen reduces 46% vertex visits compared to BKdegen (54% compared to BKrcd) at degree 100 in soc-pokec. Similar results can be seen in cit-Patents as presented in Figure 11(b). These results verify the effectiveness of our dynamic reduction and maximality check reduction.

Table 3. Ablation Study

Graph	RMCEdegen	Variant1	Variant2	Variant3
as-skitter	57.49	51.22	70.52	60.77
ca-CondMat	0.05	0.05	0.06	0.11
cit-Patents	22.14	25.71	25.85	24.86
com-dblp	0.67	0.75	0.90	0.90
com-orkut	2393.59	2475.37	2867.58	2451.96
com-youtube	4.01	3.74	4.47	4.19
email-EuAll	0.47	0.39	0.48	0.44
flickr	178.86	184.36	249.78	185.40
inf-road-usa	11.51	19.07	11.82	11.62
large_twitch	325.24	341.99	408.66	344.67
loc-gowalla	1.91	1.74	2.38	2.06
roadNet-CA	0.95	1.41	0.97	0.96
sc-delaunay_n23	11.52	9.28	13.53	12.04
soc-pokec	44.77	43.69	49.62	48.93
soc-twitter-higgs	391.48	405.62	478.73	415.12
web-Google	2.55	2.57	3.00	2.69
web-Stanford	1.51	1.52	2.08	1.53
wiki-Talk	76.68	75.63	90.74	80.63

7.4. Ablation Study

To evaluate the individual effectiveness of the proposed three reduction methods, we implement three variant algorithms, named Variant1, Variant2, and Variant3, each of which disables global reduction, dynamic reduction, and maximality check reduction, respectively. Table 3 presents the running time of these variants.

We can observe that the complete version RMCEdegen outperforms all other variants in 11 datasets. However, Variant1 runs faster in 7 datasets. This may be attributed to the overhead of global edge reduction. Nevertheless, the running time gap between Variant1 and RMCEdegen remains relatively small, confirming the overall effectiveness of global reduction. Removing the dynamic reduction technique significantly degrades the performance in most datasets (e.g., as-skitter and flickr) since it effectively prunes a substantial number of search branches during recursion. The last column of the table demonstrates that maximality check reduction consistently improves the time efficiency across all datasets. As this technique just takes linear space overhead without incurring additional computations, it provides consistent speed-up benefits. In summary, these results validate the efficiency and effectiveness of our reduction methods in optimizing the performance of the MCE algorithm.

8. Related Work

Maximal Clique Enumeration. The classic Bron-Kerbosch (B-K) algorithm(Bron and Kerbosch, 1973) is a recursive backtracking algorithm that solves MCE by maintaining three sets of vertices, i.e., $R,P$ , and $X$ . They also first propose the naive pivot technique, that is to choose the first vertex as the pivot. Tomita et al. (Tomita et al., 2006) prove that the worst-case time complexity is $O(3^{\frac{n}{3}})$ by choosing the vertex $u$ which maximizes $\lvert N(u)\cap P\rvert$ from $P\cup X$ as a pivot. Eppstein et al. (Eppstein et al., 2010) further improve the B-K algorithm with degeneracy vertex order in which each vertex has at most $\lambda$ neighbors following it. This order ensures that the size of each sub-problem is at most $d$ and also reduces the worst-case time complexity to $O(3^{\frac{\lambda}{3}})$ . Li et al. (Li et al., 2019b) propose a top-to-down approach, that repeatedly chooses and removes the vertex with the smallest degree until a clique is reached, which aims to efficiently solve the MCE in these dense degeneracy neighborhoods. Other studies have explored solving MCE using external memory (Cheng et al., 2011) or using GPUs to accelerate the B-K algorithm (Wei et al., 2021). Additionally, the output-sensitive algorithm (Tsukiyama et al., 1977; Makino and Uno, 2004; Chang et al., 2013; Conte et al., 2016) is a branching algorithm that guarantees the time interval between two consecutive outputs (also known as delay) at the polynomial level. The enumeration time of this algorithm is related to the number of maximum cliques of the final output, making it an output-sensitive algorithm.

Parallel Approach. Numerous parallel algorithms have been designed for MCE (Du et al., 2006; Schmidt et al., 2009; Lessley et al., 2017; San Segundo et al., 2018; Das et al., 2018). Du et al. (Du et al., 2006) implement a method that regards each vertex and its neighborhood $N(v)$ as a basic task, with each processor responsible for multiple basic tasks according to a simple serial number mapping. Schmidt et al. (Schmidt et al., 2009) improve load balancing of parallel algorithms through a work stealing strategy, where an idle thread randomly polls one or more search tree nodes at the bottom of the stack of other threads. Lessley et al. (Lessley et al., 2017) introduce an approach consisting of data-parallel operations on shared-memory, multi-core architectures, aiming to achieve efficient and portable performance across different architectures. Das et al. (Das et al., 2018) also present a shared-memory parallel method that parallelizes both pivot selection and sub-problem expansion.

MCE on Special Graphs. Many works focus on solving the MCE problem in other variant graphs, such as uncertain graphs(Mukherjee et al., 2015; Li et al., 2019a; Dai et al., 2022), dynamic graphs(Sun et al., 2017; Das et al., 2019), temporal graphs(Himmel et al., 2016; Molter et al., 2021), heterogeneous graphs(Hu et al., 2019), and attributed graphs(Pan et al., 2022; Zhang et al., 2023), among others. Beyond that, the maximum clique problem is closely related to MCE. Lijun Chang (Chang, 2019) introduces several efficient reduction rules to tackle the maximum clique problem. Another related task is the maximum independent set, where reduction rules have also been applied (Fomin et al., 2009; Dahlum et al., 2016; Chang et al., 2017).

9. conclusion

In this paper, we introduce a novel reduction-based framework RMCE for enumerating maximal cliques. To reduce the computation cost, RMCE incorporates powerful graph reductions including global reduction, dynamic reduction, and maximality check reduction. We conduct comprehensive experiments over 18 real graphs. The empirical results confirm the effectiveness of our proposed reduction techniques.

References

(1)
Abu-Khzam et al. (2005) Faisal N Abu-Khzam, Nicole E Baldwin, Michael A Langston, and Nagiza F Samatova. 2005. On the relative efficiency of maximal clique enumeration algorithms, with applications to high-throughput computational biology. In International Conference on Research Trends in Science and Technology. 1–10.
Biswas et al. (2013) Kamanashis Biswas, Vallipuram Muthukkumarasamy, and Elankayer Sithirasenan. 2013. Maximal clique based clustering scheme for wireless sensor networks. In 2013 IEEE Eighth International Conference on Intelligent Sensors, Sensor Networks and Information Processing. IEEE, 237–241.
Bron and Kerbosch (1973) Coen Bron and Joep Kerbosch. 1973. Algorithm 457: Finding All Cliques of an Undirected Graph. Commun. ACM 16, 9 (sep 1973), 575–577. https://doi.org/10.1145/362342.362367
Chang (2019) Lijun Chang. 2019. Efficient maximum clique computation over large sparse graphs. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining. 529–538.
Chang et al. (2017) Lijun Chang, Wei Li, and Wenjie Zhang. 2017. Computing a near-maximum independent set in linear time by reducing-peeling. In Proceedings of the 2017 ACM International Conference on Management of Data. 1181–1196.
Chang et al. (2013) Lijun Chang, Jeffrey Xu Yu, and Lu Qin. 2013. Fast maximal cliques enumeration in sparse graphs. Algorithmica 66 (2013), 173–186.
Cheng et al. (2011) James Cheng, Yiping Ke, Ada Wai-Chee Fu, Jeffrey Xu Yu, and Linhong Zhu. 2011. Finding maximal cliques in massive networks. ACM Transactions on Database Systems (TODS) 36, 4 (2011), 1–34.
Conte et al. (2016) Alessio Conte, Roberto Grossi, Andrea Marino, and Luca Versari. 2016. Sublinear-space bounded-delay enumeration for massive network analytics: Maximal cliques. In 43rd International Colloquium on Automata, Languages, and Programming (ICALP 2016), Vol. 148. 1–148.
Dahlum et al. (2016) Jakob Dahlum, Sebastian Lamm, Peter Sanders, Christian Schulz, Darren Strash, and Renato F Werneck. 2016. Accelerating local search for the maximum independent set problem. In Experimental Algorithms: 15th International Symposium, SEA 2016, St. Petersburg, Russia, June 5-8, 2016, Proceedings 15. Springer, 118–133.
Dai et al. (2022) Qiangqiang Dai, Rong-Hua Li, Meihao Liao, Hongzhi Chen, and Guoren Wang. 2022. Fast maximal clique enumeration on uncertain graphs: A pivot-based approach. In Proceedings of the 2022 International Conference on Management of Data. 2034–2047.
Das et al. (2018) Apurba Das, Seyed-Vahid Sanei-Mehri, and Srikanta Tirthapura. 2018. Shared-memory parallel maximal clique enumeration. In 2018 IEEE 25th International Conference on High Performance Computing (HiPC). IEEE, 62–71.
Das et al. (2019) Apurba Das, Michael Svendsen, and Srikanta Tirthapura. 2019. Incremental maintenance of maximal cliques in a dynamic graph. The VLDB Journal 28 (2019), 351–375.
Du et al. (2006) Nan Du, Bin Wu, Liutong Xu, Bai Wang, and Xin Pei. 2006. A parallel algorithm for enumerating all maximal cliques in complex network. In Sixth IEEE International Conference on Data Mining-Workshops (ICDMW’06). IEEE, 320–324.
Dukanovic and Rendl (2007) Igor Dukanovic and Franz Rendl. 2007. Semidefinite programming relaxations for graph coloring and maximal clique problems. Mathematical Programming 109, 2-3 (2007), 345–365.
Eppstein et al. (2010) David Eppstein, Maarten Löffler, and Darren Strash. 2010. Listing all maximal cliques in sparse graphs in near-optimal time. In Algorithms and Computation: 21st International Symposium, ISAAC 2010, Jeju Island, Korea, December 15-17, 2010, Proceedings, Part I 21. Springer, 403–414.
Fomin et al. (2009) Fedor V Fomin, Fabrizio Grandoni, and Dieter Kratsch. 2009. A measure & conquer approach for the analysis of exact algorithms. Journal of the ACM (JACM) 56, 5 (2009), 1–32.
Han et al. (2018) Shuo Han, Lei Zou, and Jeffrey Xu Yu. 2018. Speeding up set intersections in graph algorithms using simd instructions. In Proceedings of the 2018 International Conference on Management of Data. 1587–1602.
Himmel et al. (2016) Anne-Sophie Himmel, Hendrik Molter, Rolf Niedermeier, and Manuel Sorge. 2016. Enumerating maximal cliques in temporal graphs. In 2016 IEEE/ACM International Conference on Advances in Social Networks Analysis and Mining (ASONAM). IEEE, 337–344.
Hu et al. (2019) Jiafeng Hu, Reynold Cheng, Kevin Chen-Chuan Chang, Aravind Sankar, Yixiang Fang, and Brian YH Lam. 2019. Discovering maximal motif cliques in large heterogeneous information networks. In 2019 IEEE 35th International Conference on Data Engineering (ICDE). IEEE, 746–757.
Jin et al. (2022) Yan Jin, Bowen Xiong, Kun He, Yangming Zhou, and Yi Zhou. 2022. On fast enumeration of maximal cliques in large graphs. Expert Systems with Applications 187 (2022), 115915.
Leskovec and Krevl (2014) Jure Leskovec and Andrej Krevl. 2014. SNAP Datasets: Stanford Large Network Dataset Collection. http://snap.stanford.edu/data.
Lessley et al. (2017) Brenton Lessley, Talita Perciano, Manish Mathai, Hank Childs, and E Wes Bethel. 2017. Maximal clique enumeration with data-parallel primitives. In 2017 IEEE 7th Symposium on Large Data Analysis and Visualization (LDAV). IEEE, 16–25.
Li et al. (2019a) Rong-Hua Li, Qiangqiang Dai, Guoren Wang, Zhong Ming, Lu Qin, and Jeffrey Xu Yu. 2019a. Improved algorithms for maximal clique search in uncertain networks. In 2019 IEEE 35th International Conference on Data Engineering (ICDE). IEEE, 1178–1189.
Li et al. (2019b) Yinuo Li, Zhiyuan Shao, Dongxiao Yu, Xiaofei Liao, and Hai Jin. 2019b. Fast maximal clique enumeration for real-world graphs. In International Conference on Database Systems for Advanced Applications. Springer, 641–658.
Lu et al. (2018) Zhenqi Lu, Johan Wahlström, and Arye Nehorai. 2018. Community detection in complex networks via clique conductance. Scientific reports 8, 1 (2018), 5982.
Makino and Uno (2004) Kazuhisa Makino and Takeaki Uno. 2004. New algorithms for enumerating all maximal cliques. In Algorithm Theory-SWAT 2004: 9th Scandinavian Workshop on Algorithm Theory, Humlebæk, Denmark, July 8-10, 2004. Proceedings 9. Springer, 260–272.
Matsunaga et al. (2009) Tsutomu Matsunaga, Chikara Yonemori, Etsuji Tomita, and Masaaki Muramatsu. 2009. Clique-based data mining for related genes in a biomedical database. BMC bioinformatics 10 (2009), 1–9.
Molter et al. (2021) Hendrik Molter, Rolf Niedermeier, and Malte Renken. 2021. Isolation concepts applied to temporal clique enumeration. Network Science 9, S1 (2021), S83–S105.
Mukherjee et al. (2015) Arko Provo Mukherjee, Pan Xu, and Srikanta Tirthapura. 2015. Mining maximal cliques from an uncertain graph. In 2015 IEEE 31st international conference on data engineering. IEEE, 243–254.
Naudé (2016) Kevin A Naudé. 2016. Refined pivot selection for maximal clique enumeration in graphs. Theoretical Computer Science 613 (2016), 28–37.
Pan et al. (2022) Minjia Pan, Rong-Hua Li, Qi Zhang, Yongheng Dai, Qun Tian, and Guoren Wang. 2022. Fairness-aware maximal clique enumeration. In 2022 IEEE 38th International Conference on Data Engineering (ICDE). IEEE, 259–271.
Rossi and Ahmed (2015) Ryan Rossi and Nesreen Ahmed. 2015. The network data repository with interactive graph analytics and visualization. In Proceedings of the AAAI conference on artificial intelligence, Vol. 29.
San Segundo et al. (2018) Pablo San Segundo, Jorge Artieda, and Darren Strash. 2018. Efficiently enumerating all maximal cliques with bit-parallelism. Computers & Operations Research 92 (2018), 37–46.
Schmidt et al. (2009) Matthew C Schmidt, Nagiza F Samatova, Kevin Thomas, and Byung-Hoon Park. 2009. A scalable, parallel algorithm for maximal clique enumeration. Journal of parallel and distributed computing 69, 4 (2009), 417–428.
Sun et al. (2017) Shengli Sun, Yimo Wang, Weilong Liao, and Wei Wang. 2017. Mining maximal cliques on dynamic graphs efficiently by local strategies. In 2017 IEEE 33rd International Conference on Data Engineering (ICDE). IEEE, 115–118.
Tomita et al. (2006) Etsuji Tomita, Akira Tanaka, and Haruhisa Takahashi. 2006. The worst-case time complexity for generating all maximal cliques and computational experiments. Theoretical computer science 363, 1 (2006), 28–42.
Töpfer et al. (2014) Armin Töpfer, Tobias Marschall, Rowena A Bull, Fabio Luciani, Alexander Schönhuth, and Niko Beerenwinkel. 2014. Viral quasispecies assembly via maximal clique enumeration. PLoS computational biology 10, 3 (2014), e1003515.
Tsukiyama et al. (1977) Shuji Tsukiyama, Mikio Ide, Hiromu Ariyoshi, and Isao Shirakawa. 1977. A new algorithm for generating all the maximal independent sets. SIAM J. Comput. 6, 3 (1977), 505–517.
Wei et al. (2021) Yi-Wen Wei, Wei-Mei Chen, and Hsin-Hung Tsai. 2021. Accelerating the Bron-Kerbosch algorithm for maximal clique enumeration using GPUs. IEEE Transactions on Parallel and Distributed Systems 32, 9 (2021), 2352–2366.
Wen et al. (2016) Xuyun Wen, Wei-Neng Chen, Ying Lin, Tianlong Gu, Huaxiang Zhang, Yun Li, Yilong Yin, and Jun Zhang. 2016. A maximal clique based multiobjective evolutionary algorithm for overlapping community detection. IEEE Transactions on Evolutionary Computation 21, 3 (2016), 363–377.
Yu et al. (2006) Haiyuan Yu, Alberto Paccanaro, Valery Trifonov, and Mark Gerstein. 2006. Predicting interactions in protein networks by completing defective cliques. Bioinformatics 22, 7 (2006), 823–829.
Zhang et al. (2023) Qi Zhang, Rong-Hua Li, Minjia Pan, Yongheng Dai, Qun Tian, and Guoren Wang. 2023. Fairness-aware Maximal Clique in Large Graphs: Concepts and Algorithms. IEEE Transactions on Knowledge and Data Engineering (2023).
Zheng et al. (2021) Weiguo Zheng, Yifan Yang, and Chengzhi Piao. 2021. Accelerating set intersections over graphs by reducing-merging. In Proceedings of the 27th ACM SIGKDD Conference on Knowledge Discovery & Data Mining. 2349–2359.