Parameterized Aspects of Triangle Enumeration

TL;DR

This paper conducts a comprehensive parameterized complexity analysis of triangle enumeration in graphs, introducing new algorithms and kernelizations, while also establishing limitations for certain parameters.

Contribution

It presents novel parameterized algorithms and kernelizations for triangle enumeration, and explores the boundaries of efficiency improvements based on graph parameters.

Findings

New subcubic parameterized algorithms for triangle enumeration

Kernelization techniques for specific graph parameters

Negative results indicating limits of parameterized improvements

Abstract

The task of listing all triangles in an undirected graph is a fundamental graph primitive with numerous applications. It is trivially solvable in time cubic in the number of vertices. It has seen a significant body of work contributing to both theoretical aspects (e.g., lower and upper bounds on running time, adaption to new computational models) as well as practical aspects (e.g. algorithms tuned for large graphs). Motivated by the fact that the worst-case running time is cubic, we perform a systematic parameterized complexity study of triangle enumeration. We provide both positive results (new enumerative kernelizations, "subcubic" parameterized solving algorithms) as well as negative results (presumable uselessness in terms of "faster" parameterized algorithms of certain parameters such as graph diameter). To this end, we introduce new and extend previous concepts.

Tables

Table 1. Table 1: Overview of our results ( n 𝑛 n : number of vertices; m 𝑚 m : number of edges; # ​ T # T \operatorname{\#T}{} : number of triangles; k 𝑘 k : respective parameter; Δ Δ \Delta : maximum degree).

	parameter $k$	result	reference
enum-kernel	feedback edge number	{ size at most 9$k$	Prop. 4.2
		in $O\left(n+m\right)$ time
	distance to $d$-degenerate	{ at most $k+2^k+3$ vertices	Thm. 4.6
		in $O\left(n\cdot d\cdot \left(k+2^k\right)\right)$ time
solving	distance to $d$-degenerate	$O\left(k\cdot {\Delta }^2+n\cdot d^2\right)$	Prop. 4.4
	+ maximum degree $\Delta$
	feedback edge number	$O\left(k^2+n+m\right)$	Thm. 4.3
	distance to $d$-degenerate	$O\left(n\cdot d\cdot \left(k+d\right)+2^{3k}+\#T\right)$	Cor. 4.7
	distance to bipartite	$O\left(\#T+n+m\cdot k\right)$	Thm. 4.8a
	distance to chordal	$O\left(n+m\cdot k\right)$	Thm. 4.8b
	distance to cographs	$O\left(\#T+n+m\cdot k\right)$	Thm. 4.8c
	clique-width	$O\left(n^2+n\cdot k^2+\#T\right)$	Thm. 4.13
hardness	domination number,	for $k\ge 3$	Prop. 3.3
	chromatic number, and	as hard as
	diameter	the general case

Equations

$$f(\{x_1,x_2,x_3\},A)\text{vbox}..=\{\begin{array}{l}{T}_1\text{, if }\{x_1,x_2,x_3\}=\{a,b,c\}\text{, and otherwise}\\ \{\{v_1,v_2,v_3\}\mid v_1\in M(x_1)\wedge v_2\in M(x_2)\wedge v_3\in M(x_3)\}.\end{array}$$

$$V(p)=$$

$$E(p)=$$

$$T(p)=$$

$$\{\{x,y,z\}\mid x\in V(q_2)\wedge \{y,z\}\in E(q_1)\}.$$

$$E_{i,j}^v=$$

$$\bigcup _{m\in M_{u,i}}\bigcup _{l\in M_{w,j}}{F}_{u,m,w,l}\cup \bigcup _{m\in M_{u,j}}\bigcup _{l\in M_{w,i}}{F}_{u,m,w,l}$$

$$L{T}^v=L{T}^u\cup L{T}^w\cup L{T}_{u,u,w}\cup L{T}_{w,w,u}$$

$$\begin{gathered} L{T}_{x,x,y}=\bigcup _{o=1}^{h_x}\bigcup _{p=o}^{h_x}\bigcup _{q=1}^{h_y}\{\{a,b,c\}\mid a\in Q_x(o)\wedge b\in Q_x(p)\wedge c\in Q_y(q)\text{leavevmode}\wedge \\ {F}_{x,o,y,q}\ne \varnothing \wedge F_{x,p,y,q}\ne \varnothing \wedge \{a,b\}\in E_{o,p}^x\}. \end{gathered}$$

$$\displaystyle\big{\{}\{a,b,c\}\mid a\in Q_{q}(s)$$

$$\displaystyle\land F_{q,s,r,u}\neq\emptyset\land F_{q,t,r,u}\neq\emptyset\land\{a,b\}\in E^{q}_{s,t}\big{\}},$$

Full text

1 Introduction

Detecting, counting, and enumerating triangles in undirected graphs is a basic graph primitive. In an $n$-vertex graph, there can be up to $n\choose 3$ different triangles and an algorithm checking for each three-vertex subset whether it forms a triangle can list all triangles in $O({n\choose 3})$ time. As to counting the number of triangles in a graph, the best known algorithm takes $O(n^{\omega})\subset O(n^{2.373})$ time [44] and is based on fast matrix multiplication.333$\omega$ is a placeholder for the best known $n\times n$-matrix multiplication exponent. Consequently, detecting a triangle in a graph is doable in $O(n^{\omega})$ time [44] and it is conjectured that every algorithm for detecting a triangle in a graph takes at least $\Omega(n^{\omega-o(1)})$ time [1]. We mention that for $m$-edge graphs there is also an $O(m^{1.5})$-time algorithm [37] which is interesting in case of sparse graphs. Our work is motivated by trying to break such (relative or conjectured) lower bounds and improve on best known upper bounds—the twist is to introduce a secondary measurement beyond mere input size. This is also known as problem parameterization. While parameterizing problems with the goal to achieve fixed-parameter tractability results is a well-established line of research for $\mathsf{NP}$-hard problems, systematically applying and extending tools and concepts from parameterized algorithmics to polynomial-time solvable problems is still in its infancy [8, 2, 34, 23, 28, 48, 15, 25]. Performing a closer study of mostly triangle enumeration, we contribute to this line of research, also referred to as “FPT in P” for short [28]. Our central leitmotif herein is the quest for parameterized subcubic triangle enumeration algorithms.444Note that there is also the concept of P-FPT where the running time may only have a polynomial dependency on the parameter. We use the more lenient concept of FPT in P since there are known cases where an exponential dependency on the parameter is “needed” for a linear dependency on the input size.

Related work

Triangle enumeration, together with its relatives counting and detection, has many applications, ranging from spam detection [6] over complex network analysis [29, 49] and database applications [38] to applications in bioinformatics [58]. We refer to Kolountzakis et. al. [39] for an extended list of applications with small explanations why the respective triangle detection problem is relevant in each application.

The significance of the problem triggered substantial theoretical and practical work. The theoretically fastest algorithms are based on matrix multiplication and run in $O(n^{\omega}+n^{3(\omega-1)/(5-\omega)}\cdot\allowbreak\operatorname{\#T}^{2(3-\omega)/(5-\omega)})$ time, where $\operatorname{\#T}$ denotes the number of listed triangles [9]. Furthermore, there is work (including heuristics and experiments) on listing triangles in large graphs [43, 55], on triangle enumeration in the context of map reduce in graph streams [52, 5, 12], and even on quantum algorithms for triangle detection [45]. For a broader overview, we refer to a survey by Latapy [44].

As to parameterized results, early work by Chiba and Nishizeki [13] showed that all triangles in a graph can be counted in $O(m\cdot d)$ time, where $d$ is the degeneracy of the graph.555A graph $G$ is $d$-degenerate if every subgraph of $G$ contains a vertex of degree at most $d$. The degeneracy of $G$ is the smallest $d$ such that $G$ is $d$-degenerate. Thus $G$ contains at most $n\cdot d$ edges. Indeed, Chiba and Nishizeki [13] used the parameter “arboricity” of a graph, which is at most two times its degeneracy. Moreover, their algorithm can be modified to list all triangles without any substantial overhead. This running time can be improved by saving polylogarithmic factors if the number of triangles is not cubic in the number of vertices in the input graph [40], but the 3SUM-conjecture666The 3SUM problem asks whether a given set $S$ of $n$ integers contains three integers $a,b,c\in S$ summing up to 0. The 3SUM-conjecture [27] states that for any constant $\varepsilon>0$ there is no $O(n^{2-\varepsilon})$-time algorithm solving 3SUM. The connection between 3SUM and listing/detecting triangles is well studied [45, 53]. rules out more substantial improvements [41]. Green and Bader [30] described an algorithm for triangle counting running in $O(T_{K}+|K|\cdot\Delta_{K}^{2})$ time, where $K$ is a vertex cover of the input graph, $\Delta_{K}$ is the maximum degree of vertices in $K$ (with respect to the input graph), and $T_{K}$ is the time needed to compute $K$. They also described several experimental results. Recently, Coudert et al. [15] proved that both, detecting and counting triangles in a given graph, can be solved in $O(k^{2}\cdot(n+m))$ time, where $k$ is (amongst others) the clique-width of the input graph. Finally, Eppstein and Spiro [21] described a data structure that keeps track of the number of triangles in an undirected graph that changes over time (in each step a new edge can be inserted or an existing one can be deleted). They described the time complexity of updating their data structure in terms of the $h$-index of the current graph.777The $h$-index of a graph is the maximum number $h$ such that the graph contains at least $h$ vertices of degree at least $h$.

Complementing algorithmic results, the problems of detecting and counting triangles have been studied from a running-time-lower-bounds perspective, where the lower bounds are based on popular conjectures like, for instance, the Strong Exponential-Time Hypothesis [36, 35]. Accordingly, lower bounds have been proven for detecting (in a given edge-weighted graph) a triangle of negative weight [57] or counting (in a given vertex-colored graph) triangles with pairwise different colors on the vertices [3]. Recently, making use of the above mentioned results [57, 3], lower bounds on strict kernelization, that is kernelization where the parameter in the kernel is not allowed to increase, have been proven for both problems when parameterized by, for instance, the maximum degree or the degeneracy of the given graph [24]; Additionally, for both problems with the same parameterization, a strict kernel of cubic size computable in $O(n^{5/3})$ time has been shown.

Our contributions

We systematically explore the parameter space for triangle enumeration and classify the usefulness of the parameters for FPT-in-P algorithms. In doing so, we extend a concept of enumerative kernelization given by Creignou et al. [18] and present a novel hardness concept, as well as algorithmic results. Our concrete results are surveyed in Table 1. We refer to the respective sections for motivation and a formal definition of the various parameters.

In particular, we provide enumerative problem kernels with respect to the parameters “feedback edge number” and “distance to $d$-degenerate graphs”. Partially based on data reduction algorithms, we provide fast algorithms for several parameters such as feedback edge number, (vertex-deletion) distance to bipartite graphs, chordal graphs, cographs and to $d$-degeneracy (the last one with and without the additional parameter maximum vertex degree), and clique-width. On the negative side, using a concept we call “General-Problem-hardness”, we show that using the parameters domination number, chromatic number, and diameter do not help to get FPT-in-P algorithms for detecting triangles, that is, even for constant parameter values the problem remains as “hard” as the general version with unbounded parameter.

Organization

The remainder of this work is organized as follows. In Section 2 we fix some notation and explain basic concepts. Then, in Section 3, we introduce a new notion of hardness (GP-hardness) and of kernelization (enum-advice kernelization), give a small example for each of them, and state our main negative result. In Section 4 we provide the positive results of our work. We conclude in Section 5 and state some directions for further research.

2 Preliminaries

Notation

For an integer $\ell\geq 1$, let $[\ell]=\{1,\ldots,\ell\}$. Let $G=(V,E)$ be an undirected simple graph. We also denote by $V(G)$ and $E(G)$ the vertex set and the edge set of $G$, respectively. We set $n\mathrel{\vbox{\hbox{\scriptsize.}\hbox{\scriptsize.}}}=|V|$, $m\mathrel{\vbox{\hbox{\scriptsize.}\hbox{\scriptsize.}}}=|E|$, and $|G|\mathrel{\vbox{\hbox{\scriptsize.}\hbox{\scriptsize.}}}=n+m$.

We denote by $N(v)$ the (open) neighborhood of a vertex $v\in V$ and by ${\operatorname{deg}(v)\mathrel{\vbox{\hbox{\scriptsize.}\hbox{\scriptsize.}}}=|N(v)|}$ the degree of $v$. By $G[U]$ we denote the subgraph of $G$ induced by the vertex subset $U\subseteq V$ and $G-U\mathrel{\vbox{\hbox{\scriptsize.}\hbox{\scriptsize.}}}=G[V\setminus U]$. A vertex subset $U\subseteq V$ is a vertex cover of $G$ if $G-U$ contains no edges. If $\{x,y,z\}\subseteq V$ induces a triangle in a graph, we refer to $T=\{x,y,z\}$ as this triangle. We denote the number of triangles in the graph by $\operatorname{\#T}$. Our central problem is as follows.

Triangle Enumeration ($\triangle$-Enum)

[TABLE]

Parameterized Complexity

A language $L\subseteq\Sigma^{*}\times\mathds{N}$ is a parameterized problem over some finite alphabet $\Sigma$, where $(x,k)\in\Sigma^{*}\times\mathds{N}$ denotes an instance of $L$ and $k$ is the parameter. For a parameterized problem $L$, the language $\hat{L}=\{x\in\Sigma^{*}\mid\exists k\colon(x,k)\in L\}$ is called the unparameterized problem associated with $L$. Then $L$ is called fixed-parameter tractable (equivalently, $L$ is in the class FPT) if there is an algorithm that on input $(x,k)$ decides whether $(x,k)\in L$ in $f(k)\cdot|x|^{O(1)}$ time, where $f$ is some computable function only depending on $k$ and $|x|$ denotes the size of $x$. We call an algorithm with a running time of the form $f(k)\cdot|x|$ a linear-time FPT algorithm. Creignou et al. [18, Definition 3.2] introduced the concept of FPT-delay algorithms for enumeration problems. An algorithm $\mathcal{A}$ is an FPT-delay algorithm if there exist a computable function $f$ and a polynomial $p$ such that $\mathcal{A}$ outputs for every input $x$ all solutions of $x$ with at most $f(k)\cdot p(|x|)$ time between two successive solutions. If the delay can be upper-bounded in $p(|x|)$, then the algorithm is called a $p$-delay algorithm. A kernelization for $L$ is an algorithm that on input $(x,k)$ computes in time polynomial in $|x|+k$ an output $(x^{\prime},k^{\prime})$ (the kernel) such that

1. (i)

$(x,k)\in L\iff(x^{\prime},k^{\prime})\in L$, and 2. (ii)

$|x^{\prime}|+k^{\prime}\leq g(k)$ for some computable function $g$ only depending on $k$.

The value $g(k)$ denotes the size of the kernel. It is well-known that a decidable parameterized problem $P$ is in FPT if and only if $L$ admits a kernelization.

We can associate a graph parameter $k$ with a function $\kappa\colon\mathcal{G}\to\mathds{N}\cup\{\infty\}$ that maps every graph $G$ to its parameter value, where $\mathcal{G}$ denotes the family of all graphs. We say that $k$ lower-bounds a parameter $k^{\prime}$, associated with function $\kappa^{\prime}$, if there is a function $f\colon\mathds{N}\to\mathds{N}$ such that for every graph $G\in\mathcal{G}$ it holds that $\kappa(G)\leq f(\kappa^{\prime}(G))$ (respectively, we say $k^{\prime}$ upper-bounds $k$). If for two parameters it holds that none of them lower-bounds the other, we say that the two parameters are unrelated.

Our work focuses on enumeration, while the great majority of parameterized complexity works study decision (or search and optimization) problems.

Definition 2.1** ([18, Definition 1]).**

A parameterized enumeration problem is a pair $(P,\mathtt{Sol})$ such that

• •

$P\subseteq\Sigma^{*}\times\mathds{N}$ is a parameterized problem over a finite alphabet $\Sigma$ and

• •

$\mathtt{Sol}\colon\Sigma^{*}\times\mathds{N}\rightarrow\mathcal{P}(\Sigma^{*})$ is a function such that for all $(x,k)\in\Sigma^{*}\times\mathds{N}$, $\mathtt{Sol}(x,k)$ is a finite set and $\mathtt{Sol}(x,k)\neq\emptyset\iff(x,k)\in P$.

Intuitively, the function $\mathtt{Sol}$ contains for each instance $(x,k)$ of $P$ the set of all solutions. Given an instance $(x,k)$, the task is then to compute $\mathtt{Sol}(x,k)$.

3 New Notions of Hardness and Kernelization

In this section we introduce two new notions and demonstrate their usefulness. The first notion is a many-one reduction that relates a parameterized problem to its unparameterized counterpart. We call it “General-Problem-hardness” as it proves the parameterized version to be as hard as the unparameterized (general) problem. The second concept is an adaption of an existing kernelization concept for enumeration problems. It uses some additional space in order to avoid encoding everything in the kernel instance.

3.1 Computational Hardness

We show hardness for the following problem.

Triangle Detection ($\triangle$-Detect)

[TABLE]

Since $\triangle$-Detect is a special case of $\triangle$-Enum, it follows that any lower bound for $\triangle$-Detect implies the same lower bound for $\triangle$-Enum. Thus, if a certain parameter does not admit a solving algorithm for $\triangle$-Detect in some (parameterized) time $X$, then $\triangle$-Enum does not either.

Before giving a formal definition of our concept, consider as an introductory example the parameter minimum degree. Adding an isolated vertex to any graph in constant time leaves the set of triangles unchanged and the resulting graph has minimum degree zero. Hence, one cannot use the parameter minimum degree to design faster algorithms for $\triangle$-Detect. Upon this trivial example, we study which parameters for $\triangle$-Detect cannot be used to design linear-time FPT algorithms under the hypothesis that $\triangle$-Detect is not linear-time solvable [1]. To this end we reduce an arbitrary instance of $\triangle$-Detect

(i) in linear time to

(ii) a new equivalent instance of some parameterized version of the problem such that

(iii) the parameter is upper-bounded by a constant.

The corresponding notion of a many-one reduction (also for non-linear running times) is as follows.

Definition 3.1**.**

Let $P\subseteq\Sigma^{*}\times\mathds{N}$ be a parameterized problem, let $Q\subseteq\Sigma^{*}$ be the unparameterized problem associated with $P$, and let $f\colon\mathds{N}\rightarrow\mathds{N}$ be a polynomial function. We call $P$ $\ell$-General-Problem-hard$(f)$ ($\ell$-GP-hard$(f)$) if there exists an algorithm $\cal{A}$ transforming any input instance $x$ of $Q$ into an instance $(x^{\prime},k^{\prime})$ of $P$ such that

1. (G1)

$\cal{A}$ runs in $O(f(|x|))$ time, 2. (G2)

$x\in Q\iff(x^{\prime},k^{\prime})\in P$, 3. (G3)

$k^{\prime}\leq\ell$, and 4. (G4)

$|x^{\prime}|\in O(|x|)$.

We call $P$ General-Problem-hard$(f)$ (GP-hard$(f)$) if there exists an integer $k$ such that $P$ is $k$-GP-hard$(f)$. We omit the running time and call $P$ $k$-General-Problem-hard ($k$-GP-hard) if $f$ is a linear function.

Let $P$ be some parametrized problem being $\ell$-GP-hard($f$) for some polynomial $f$. Suppose that we can exclude an algorithm solving $Q$, the unparameterized version of $P$, in $O(f(|x|))$ time under some assumption $A$. Since $P$ is $\ell$-GP-hard($f$), there is an algorithm computing for any instance $x$ of $Q$ an equivalent instance $(x^{\prime},k^{\prime})$ of $P$ in $O(f(|x|))$-time. Then, under assumption $A$, we can exclude the existence of a $g(k)\cdot f(|x|)$-time algorithm for $P$ for any computable function $g$ due to the following. Since $k^{\prime}\leq\ell$, with $\ell$ being a constant, we have $g(k)\in O(1)$. Since $|x^{\prime}|\in O(|x|)$ and $f$ is some polynomial, we have $f(|x^{\prime}|))\in O(f(|x|))$. Altogether, the two algorithms provide an $O(f(|x|))$-time algorithm, breaking assumption $A$.

In a nutshell, a parameterized problem $P$ being GP-hard is (unconditionally) at least as hard to solve as its unparameterized problem associated with $P$, formally:

Lemma 3.2**.**

Let $f\colon\mathds{N}\rightarrow\mathds{N}$ be a function, let $P\subseteq\Sigma^{*}\times\mathds{N}$ be a parameterized problem that is $\ell$-GP-hard$(f)$, and let $Q\subseteq\Sigma^{*}$ be the unparameterized problem associated with $P$. If there is an algorithm solving each instance $(x,k)$ of $P$ in $g(k)\cdot f(|x|)$ time, then there is an algorithm solving each instance $x^{\prime}$ of $Q$ in $O(f(|x^{\prime}|))$ time.

Proof.

Assume that there is an algorithm $\cal{B}$ which solves each instance $(x,k)$ of $P$ in ${O(g(k)\cdot f(|x|))}$ time. Let $x_{Q}$ be an arbitrary instance of $Q$. Since $P$ is $\ell$-GP-hard$(f)$, there is an algorithm $\cal{A}$ which transforms $x$ into a new instance $(x^{\prime},k^{\prime})$ of $P$ in $O(f(|x|))$ time such that $k^{\prime}\leq\ell$, $|x^{\prime}|\in O(|x|)$, and ${x\in Q}$ if and only if $(x^{\prime},k^{\prime})\in P$.

By assumption, algorithm $\cal{B}$ solves $(x^{\prime},k^{\prime})$ in $g(k^{\prime})\cdot f(|x^{\prime}|)$ time. Since $k^{\prime}\leq\ell$ and $|x^{\prime}|\in O(|x|)$, it holds that $g(k^{\prime})\cdot f(|x^{\prime}|)\in O(f(|x|))$. Since $x\in Q$ if and only if $(x^{\prime},k^{\prime})\in P$ holds, this algorithm solves $Q$ in $O(f(|x|))$ time. ∎

It is folklore that $\triangle$-Detect in tripartite graphs is as hard as the general case (see, e.g., [9, Section 5]). We show that $\triangle$-Detect with respect to each of the parameters domination number, chromatic number, and diameter is $3$-GP-hard. Indeed, we also show that $\triangle$-Detect is $9$-GP-hard for the sum of the three parameters. The domination number of a graph is the size of a minimum cardinality set $S$ with $\bigcup_{v\in S}N(v)\cup S=V$. The chromatic number of a graph is the minimum number of colors needed to color the vertices such that no edge contains vertices of the same color. The diameter of a graph is the length of the longest shortest path between two vertices.

Proposition 3.3**.**

$\triangle$-Detect* is $3$-GP-hard with respect to each domination number, chromatic number, and diameter. Moreover, $\triangle$-Detect is $9$-GP-hard with respect to the sum of domination number, chromatic number, and diameter.*

Proof.

Let $G=(V,E)$ be an instance of Triangle Detection. Let $V=\{v_{1},\ldots,v_{n}\}$. We construct a graph ${G^{\prime}=(V^{\prime},E^{\prime})}$ in time linear in the size of $G$ such that $G$ contains a triangle if and only if $G^{\prime}$ contains a triangle. Moreover, $G^{\prime}$ has domination number, chromatic number, and diameter at most three.

We refer to Figure 1 for an illustrative example of the following construction of $G^{\prime}$.

Let $G^{\prime}$ be initially empty. Add three copies $V^{\prime}_{1},V^{\prime}_{2},V^{\prime}_{3}$ of $V$ to $G^{\prime}$, and let $V^{\prime}_{i}=\{v_{1}^{i},\ldots,v_{n}^{i}\}$, $i\leavevmode\nobreak\ \in\leavevmode\nobreak\ \{1,2,3\}$. For each edge $\{v_{x},v_{y}\}\in E$, add the edge set ${\{\{v_{x}^{i},v_{y}^{j}\}\mid i,j\in\{1,2,3\},i\neq j\}}$ to $G^{\prime}$. Add the vertex sets $L=\{\ell_{1},\ell_{2},\ell_{3}\}$ and ${R=\{r_{1},r_{2},r_{3}\}}$ to $G^{\prime}$. For each ${i\in\{1,2,3\}}$, connect $\ell_{i}$, $r_{i}$ with each vertex in $V_{i}^{\prime}$ by an edge, that is, add $\{\{\ell_{i},v_{x}^{i}\},\{r_{i},v_{x}^{i}\}\mid i\in\{1,2,3\},x\in[n]\}$ to the edge set of $G^{\prime}$. Finally, for ${i\neq j}$, connect ${\ell_{i}\in L}$ with ${r_{j}\in R}$ by an edge in $G^{\prime}$, that is, add the edge set $\{\{l_{i},r_{j}\}\mid i,j\in\{1,2,3\},i\neq j\}$. This completes the construction of $G^{\prime}$.

We prove that the properties (G1)–(G4) of Definition 3.1 are fulfilled. Note that $G^{\prime}$ is constructed in $O(|G|)$ time (G1) and contains $3n+6$ vertices and ${6m+6n+6}$ edges (G4). Observe that each $V_{i}^{\prime}$, $i\in\{1,2,3\}$, forms an independent set in $G^{\prime}$. In addition, each vertex set $N(\ell_{i})$, $N(r_{i})$, $i\in\{1,2,3\}$, forms an independent set in $G^{\prime}$.

Next, we prove that $G$ contains a triangle if and only if $G^{\prime}$ contains a triangle (G2). Suppose that $\{v_{x},v_{y},v_{z}\}$ forms a triangle in $G$. Then, by construction of $G^{\prime}$, $G^{\prime}$ contains the vertices $v_{x}^{1}$, $v_{y}^{2}$, and $v_{z}^{3}$ and the edges $\{v_{x}^{1},v_{y}^{2}\}$, $\{v_{y}^{2},v_{z}^{3}\}$, and $\{v_{x}^{1},v_{z}^{3}\}$. Hence, $\{v_{x}^{1},v_{y}^{2},v_{z}^{3}\}$ forms a triangle in $G^{\prime}$.

Conversely, suppose that $\{x,y,z\}$ forms a triangle in $G^{\prime}$. As $V_{i}^{\prime}$, $N(\ell_{i})$, and $N(r_{i})$ form independent sets for each $i\in\{1,2,3\}$ in $G^{\prime}$, $\{x,y,z\}$ does not contain $\ell_{i}$, $r_{i}$, or at least two vertices of $V_{i}^{\prime}$, $i\in\{1,2,3\}$. It follows that for each $i\in\{1,2,3\}$ it holds $|\{x,y,z\}\cap V_{i}^{\prime}|=1$. Let without loss of generality be $x=v_{a}^{1}\in V^{\prime}_{1}$, $y=v_{b}^{2}\in V^{\prime}_{2}$, and $z=v_{c}^{3}\in V^{\prime}_{3}$. As for $i\neq j$ it holds that $\{v_{a}^{i},v_{b}^{j}\}\in E^{\prime}$ if and only if $\{v_{a},v_{b}\}\in E$, it follows that $\{v_{a},v_{b},v_{c}\}$ forms a triangle in $G$.

Last, we prove that the domination number, the chromatic number, and the diameter of $G^{\prime}$ are all at most $3$ (G3). As for each $i\in\{1,2,3\}$, each vertex in $V^{\prime}_{i}$ is connected with $\ell_{i}$, and $N(r_{i})\cap L\neq\emptyset$, the set $L$ is a dominating set in $G^{\prime}$. As each $V^{\prime}_{i}$, $i\in\{1,2,3\}$, is an independent set in $G^{\prime}$, color the vertices of $V_{i}^{\prime}$ with color $i$. Next, color the vertices $\ell_{i},r_{i}$ with color $1+(i\mod 3)$ for each $i\in\{1,2,3\}$. This forms a valid coloring of the vertices in $G^{\prime}$ with at most three colors. Observe that since $V_{i}\cup R\setminus\{r_{i}\}\in N(\ell_{i})$ and $V_{i}\cup L\setminus\{\ell_{i}\}\in N(r_{i})$, each vertex in $G^{\prime}$ has distance at most two to $\ell_{i}$ and $r_{i}$, for each $i\in\{1,2,3\}$. As each vertex in $V_{1}^{\prime}\cup V_{2}^{\prime}\cup V_{3}^{\prime}$ has a neighbor in $L\cup R$, it follows that $G^{\prime}$ is of diameter at most three.

Altogether, (G1)–(G4) of Definition 3.1 are satisfied and hence the proposition follows. ∎

3.2 Enum-Advice Kernelization

The second new notion we introduce in this paper is an adaption of an enumerative kernelization concept due to Creignou et al. [18].

The aim of kernelization is to efficiently reduce a large instance of a computationally hard, say $\mathsf{NP}$-hard, problem to an “equivalent” instance (called “kernel”) whose size only depends on the parameter and not on the size of the original input instance. Then, solving the kernel by a trivial brute-force algorithm often significantly reduces the overall running time. This technique is by no means restricted to computationally hard problems even though it was invented to tackle problems for which no polynomial-time algorithms are known.

Observe that kernelization is usually defined for decision problems only. Creignou et al. [18] developed a concept to address enumeration problems. Roughly speaking, their concept requires that all solutions of the input instance can be recovered from the input instance and the solutions of the kernel (see Figure 22(a)). We modify the concept by adding a generic object which we call the advice of the kernelization. The intention behind this change is that in order to compute all solutions of the input instance, one only needs the kernel and the advice (which might be much smaller than the input instance), see Figure 2 for an illustration. In the examples we provide in this paper, in the advice we store information about all triangles that are destroyed by data reduction rules.

We will now give a formal definition of our new enumerative kernelization concept and then discuss the potential advantages compared to the concept by Creignou et al. [18].

Definition 3.4**.**

Let $(P,\mathtt{Sol})$ be a parameterized enumeration problem. Let $\mathcal{R}$ be an algorithm which for every input $(x,k)$ computes in time polynomial in $|x|+k$ a pair $(I(x,k),\allowbreak A(x,k))$. We call $\mathcal{R}$ an enum-advice kernelization of $(P,\mathtt{Sol})$ if

1. (K1)

there exists a function $h$ such that for all $(x,k)$ it holds that $|I(x,k)|\leq h(k)$, 2. (K2)

for all $(x,k)$ it holds that $(x,k)\in P\iff I(x,k)\in P$, and 3. (K3)

there exists a function $f$ such that for all $(x,k)\in P$

1. (a)

$\forall p,q\in\mathtt{Sol}(I(x,k))\colon p\neq q\implies f(p,A(x,k))\cap f(q,A(x,k))=\emptyset$, 2. (b)

$\bigcup_{w\in\mathtt{Sol}(I(x,k))}f(w,A(x,k))=\mathtt{Sol}(x,k)$, and 3. (c)

there exists an algorithm $\mathcal{T}_{f}$ such that for every $(x,k)\in P$ and ${w\in\mathtt{Sol}(I(x,k))}$, ${\mathcal{T}_{f}}$ computes $f(w,A(x,k))$ in FPT-delay time [18].

If $\mathcal{R}$ is an enum-advice kernelization of $(P,\mathtt{Sol})$, then $I(x,k)$ is called the kernel of $(x,k)$ and $A(x,k)$ is called the advice of $I(x,k)$. If algorithm $\mathcal{T}_{f}$ has $p$-delay time for some polynomial $p$ $($only in $|x|)$, then we say that the problem admits a $p$-delay enum-advice kernel.

Clearly, since every polynomial-time solvable enumeration problem has a trivial enum-advice kernelization, we are only interested in those kernelizations where $\mathcal{R}$ and $\mathcal{T}_{f}$ are both significantly faster than the best (known) algorithms to solve the enumeration problem.

We will now discuss the potential advantages of our new definition compared to enum-kernelization. The advice can be used to design faster algorithms since the advice might be much smaller than the input instance, as described in the following example. Observe that one can set $A(x,\ell)=(x,\ell)$, and thus enum-advice kernelization is a generalization of enum-kernelization.

Example 3.5**.**

Consider the Enum Vertex Cover problem parameterized by solution size $k$; here the task is to list all minimal vertex covers of size at most $k$ of an input graph $G$. As observed by Creignou et al. [18, Proposition 1], the standard Buss’ kernelization [20] provides an enum-kernelization for this problem. It consists of the following two data reduction rules:

If $\operatorname{deg}(v)>k$, then remove $v$ and all edges incident with $v$ from $G$ and decrease $k$ by one ($v$ is contained in every vertex cover of size at most $k$). 2. 2.

If $\operatorname{deg}(v)=0$, then remove $v$ from $G$ (no minimal vertex cover contains $v$).

Let $G^{\prime}$ be the graph obtained from exhaustively applying the two data reduction rules on $G$ such that none of the two rules is applicable to $G^{\prime}$. If $G^{\prime}$ contains more than $k^{2}$ edges, then return the complete graph of $k+2$ vertices as there is no vertex cover of size $k$. Otherwise, return graph $G^{\prime}$.

Let $V_{D}$ be the set of vertices that are deleted by the first rule. The set of minimal vertex covers in the input graph $G$ can be obtained by adding $V_{D}$ to each minimal vertex cover in the kernel $G^{\prime}$. For the set of minimal vertex covers of $G$ of size at most $k$ one considers only minimal vertex covers in $G^{\prime}$ that have size at most $k-|V_{D}|$. In an enum-advice kernel one can store $V_{D}$ in the advice, which then has size $O(k)$. To compute all minimal vertex covers in $G$, we compute all minimal vertex covers in $G^{\prime}$ and add $V_{D}$ to each. As $|V_{D}|\leq k$, we can add $V_{D}$ to a computed minimal vertex cover of $G^{\prime}$ in $O(k)$ time. In contrast, the enum-kernelization concept would require to (re-)compute $V_{D}$ for each minimal vertex cover in $G^{\prime}$ which requires time linear in the size of $G$. We refer to Figure 3 for an illustration. When considering $\mathsf{NP}$-hard problems replacing a term like $n+m$ by $k$ might be only a small improvement, but for polynomial-time solvable problems (like $\triangle$-Enum) it can have a significant impact.

As discussed in the above example, the advice can be used to efficiently compute the solutions from the kernel. In general, enumeration algorithms can be derived from enum-advice kernels as stated in the next lemma.

Lemma 3.6**.**

Let $\mathcal{R}$ be an enum-advice kernelization of a parameterized enumeration problem $(P,\mathtt{Sol})$ such that for every instance $(x,k)$ of $P$:

• •

$\mathcal{R}$* runs in $O((|x|+k)^{c})$ time for some constant $c$;*

• •

the unparameterized version of $P$ can be solved in $g(|x|)$ time on $x$;

• •

the kernelization computes the pair $(I,A)$ where $|I|\leq h(k)$, and algorithm $\mathcal{T}_{f}$ takes $O(|I|^{d})$ time between generating two solutions for some constant $d$; and

• •

$\operatorname{\#s}$* denotes the number of solutions in $I$ and $\operatorname{\#S}$ denotes the number of solutions in $x$.*

Then, $(P,\mathtt{Sol})$ can be solved in $O((|x|+k)^{c}+g(h(k))+(\operatorname{\#s}+\operatorname{\#S})\cdot h(k)^{d})$ time.

Proof.

We use the notation as stated in the lemma and assume that all stated conditions hold. We will prove that there exists an algorithm solving $(P,\mathtt{Sol})$ in $O((|x|+k)^{c}+g(h(k))+(\operatorname{\#s}+\operatorname{\#S})\cdot h(k)^{d})$ time.

First, compute the kernel $(I,A)$ in $O((|x|+k)^{c})$ time. Second, find all solutions in $I$ in $g(|I|)\in O(f(h(k)))$ time. Third, compute $\bigcup_{w\in\mathtt{Sol}(I)}f(w,A)$. This can be done by running $\mathcal{T}_{f}$ on every solution in $I$. There are $\operatorname{\#s}$ solutions in $I$, hence there are $\operatorname{\#s}$ iterations of $\mathcal{T}_{f}$. The algorithm therefore spends at most $O(\operatorname{\#s}\cdot|I|^{d})$ time as precalculation or postcalculation time. We refer to Creignou et al. [18] for a formal definition of pre- and postcalculation time. Informally, precalculation time is the time from the start of the calculation until the first solution is listed and postcalculation time is the time needed after the last solution is listed. Apart from pre- and postclaculation time, the time between two solution outputs is at most $O(|I|^{d})\subseteq O(h(k)^{d})$. Since there are $\operatorname{\#S}$ solutions in $x$, computing all solutions takes $(\operatorname{\#s}+\operatorname{\#S})\cdot(h(k))^{d}$ time. Thus, this algorithm takes $O((|x|+k)^{c}+g(h(k))+(\operatorname{\#s}+\operatorname{\#S})\cdot h(k)^{d})$ time. ∎

Note that in general we cannot give any meaningful upper bound on the delay of the constructed algorithm as the kernel instance might be packed with solutions $p$ such that $f(w,A)=\emptyset$. If no such solutions exist, then the delay of the described algorithm is $O((|x|+k)^{c}+f(h(k))+h(k)^{d}))$. The delay of all algorithms presented in our work is only upper-bounded by the respective running times of the algorithms.

4 Algorithms

In this section, we present FPT algorithms solving $\triangle$-Enum exploiting several parameters. We systematically explore the parameter space along a hierarchy of graph parameters (see [56]) in the following way (Figure 4 surveys our line of attack). We start from the fact that $\triangle$-Enum allows for an $O(m\cdot d)$-time algorithm when parameterized by degeneracy $d$ [13], and go into the following two directions: First, we study in Section 4.1 whether parameters upper-bounding degeneracy admit algorithms running in ${f(k)+O(n+m)}$ time, where $k$ is the respective parameter value. Kernelization is one way to achieve such additive ($f(k)+O(n+m)$) instead of multiplicative ($f(k)\cdot O(n+m)$) running times. Indeed, we will present enum advice-kernelizations in this section. Second, we study in Section 4.2 parameters that are incomparable with degeneracy and so far have been unclassified.

We remark that in most of our running times the dependency on the parameter is modest. Thus, in scenarios where the respective parameter is small, the corresponding algorithms should be suitable for implementation.

4.1 Parameters Lower-Bounded By Degeneracy

In this section we show results on graph parameters that upper-bound a graph’s degeneracy. In each subsection, we first describe the respective parameter and then turn to the results.

4.1.1 Feedback Edge Number

We begin with feedback edge number. A feedback edge set in a graph is a subset of the edges such that removing the edges from the graph results in a forest. The feedback edge number of a graph is the size of a minimum feedback edge set. Graphs with small feedback edge set number are “almost trees”; such social networks occur in the context of sexually transmitted infections [54] and extremism propagation [26]. This parameter was recently used to achieve a significant speed-up in the computation of maximum matchings [42]. The feedback edge number is neither related to the distance to [math]-degenerate graphs (vertex cover number) nor to the maximum degree, but it upper-bounds the distance to $1$-degenerate graphs (feedback vertex number). Note that the feedback edge number is $m-n+c$ where $c$ is the number of connected components. Hence the parameter can be of order $O(m)$. It can be computed in linear time by e. g. breadth-first-search. We hence assume that an optimal feedback edge set is given.

We first provide a key lemma and then state a linear-size enum-advice kernel for $\triangle$-Enum parameterized by feedback edge number. Recall that the feedback edge number of a graph is the size of a smallest subset of the edges such that removing the edges from the graph results in a forest.

Lemma 4.1**.**

Let $G=(V,E)$ be an undirected graph and let $F$ be a feedback edge set in $G$. All triangles $\{u,v,w\}$ where at least one of the edges between the three vertices is not in $F$ can be enumerated in $O(n+m)$ time. There are at most $2|F|$ such triangles.

Proof.

Let $G^{\prime}=(V,E\setminus F)$ be an arbitrarily rooted forest and let $p(v)$ denote the parent of a vertex $v$ in it. Note that $F$, $G^{\prime}$, and $p$ can be computed in $O(n+m)$ time. Observe further that all edges in $E\setminus F$ are of the form $\{v,p(v)\}$ for some vertex $v$ and hence every triangle $\{u,v,w\}$ in $G$ where at least one of the edges between the three vertices is not in $F$ is of the form $\{u,v,p(v)\}$ for some vertices $u,v$. Note that there are at most two such triangles per edge in $F$. We can list all such triangles in linear time by the following algorithm. We first mark all edges in $F$ so that we can check for each edge in constant time whether it is in $F$ or in $E\setminus F$. We first iterate over all vertices $v\in V$ and find all triangles where exactly two edges between the three vertices are in $F$ in overall linear time. We iterate over all edges ${v,w}$ incident to $v$ and if $\{v,w\}\in F$, then we mark $w$. Afterwards, we iterate again over all neighbors $w$ of $v$ and if both $w$ and $p(w)$ are marked, then we list $\{v,w,p(w)\}$ as a triangle. In a third iteration we remove all markings from the neighbors of $v$. It remains to list all triangles with exactly one edge in $F$. To this end, we iterate over all edges $\{u,v\}\in F$ and check whether $p(u)=p(v)$, $p(p(u))=v$, or $u=p(p(v))$ in constant time. The algorithm takes linear time as $O(\sum_{v\in V}\deg v)=O(m)$.

Assume towards a contradiction that there is a triangle $\{x,y,z\}$ in $G$ which is not listed by the described algorithm and where at least one edge between these three vertices is not in $F$. Without loss of generality let $\{x,y\}\in E\setminus F$. Since $G^{\prime}$ is a rooted forest, either $x$ is the parent of $y$ or $y$ is the parent of $x$. Let without loss of generality be $y=p(x)$. Since $\{x,y,z\}$ is a triangle, it holds that $\{y,z\}\in E$. If $\{y,z\}\in F$, then $\{x,y,z\}$ is listed when choosing $v=x$ in the algorithm above. By construction, both $y$ and $z$ are marked in the first iteration and then $\{x,y,z\}$ is listed in the second iteration. If $\{y,z\}\in E\setminus F$, then  either $y=p(z)$ or $p(y)=z$. In the former case it holds that $p(x)=y=p(z)$ and in the latter case it holds that $z=p(y)=p(p(x))$ and $\{x,y,z\}$ is therefore listed. ∎

Using this we can easily show the following enum-advice kernel.

Proposition 4.2**.**

$\triangle$-Enum* parameterized by feedback edge number $k$ admits a constant-delay enum-advice kernel with at most $2k+3$ vertices and ${k+3}$ edges. It can be computed in $O(n+m)$ time.*

Proof.

Construct an enum-advice kernel $(I=I(G,k),A=A(G,k))$ as follows. For every edge $e\in F$ put $e$ and both of its endpoints into the graph. Compute the feedback edge number $k^{\prime}\leq k$ of $G_{I}$ in linear time. Compute all triangles in $G$ with at least one edge in $E\setminus F$ and set $A$ to be the set of all triangles found. If $A\neq\emptyset$, then add one extra triangle $\{x,y,z\}$ where $x,y,z\notin V$. Lemma 4.1 shows that there are at most $2k$ such triangles and that they can be computed in linear time. Observe that each step can be done in $O(n+m)$ time. Set the function $f(\{x,y,z\},A)=A$ and $f(w,A)=\{w\}$ for each $w\in\operatorname{Sol}(I),w\neq\{x,y,z\}$.

We prove that the algorithm fulfills conditions (K1)–(K3) of Definition 3.4.

By construction, for each edge in $F$ there are at most two vertices and one edge put into $I$. There is at most one extra triangle added with three vertices and three edges. Thus, it holds that $|G_{I}|\leq\leavevmode\nobreak\ 3\cdot k+3$ (K1).

Assume that there is a triangle $T=\{v_{x},v_{y},v_{z}\}$ in $G$. It either contains at least one edge in $E\setminus F$ or only edges in $F$. In the first case $G_{I}$ contains the triangle $\{x,y,z\}$ and in the second case $G_{I}$ contains $T$. Analogously, if $G_{I}$ contains a triangle $T^{\prime}$, then it is either $\{x,y,z\}$ or not. If it is, then, by construction, $A\neq\emptyset$ and hence $G$ contains a triangle in $A$. If it is not, then $T^{\prime}$ is also contained in $G$. Thus $G$ contains a triangle if and only if $G_{I}$ contains a triangle (K2).

It remains to discuss the properties (K3) of function $f$.

For $p,q\in\mathtt{Sol}(I)\setminus\{x,y,z\}$, if $p\neq q$, then $f(p,A)\cap f(q,A)=\{p\}\cap\{q\}=\emptyset$. If $p$ or $q$ is $\{x,y,z\}$ (without loss of generality $p=\{x,y,z\}$), then $f(p,A)$ only contains triangles with at least one edge not in $F$ and $f(q,A)=\{q\}$ contains only a triangle where all edges are in $F$. It follows that $f(p,A)\cap f(q,A)=\emptyset$ (K3a).

By construction and by Lemma 4.1, $f(\{x,y,z\},A)$ contains all triangles in $G$ where at least one of the edges is not in $F$. Since all edges in $F$ are included in $G_{I}$, all other triangles are contained in $G_{I}$ (K3b).

It is easy to see that $f$ can be computed in constant-delay time (K3c) by either iterating over $A$ or just forwarding $w$. ∎

To the best of our knowledge, there is no known algorithm that solves $\triangle$-Enum in $O(n+m)$ or constant-delay time.

A straight-forward application of Lemma 3.6 combined with Proposition 4.2 yields the following.

Theorem 4.3**.**

$\triangle$-Enum* parameterized by feedback edge number $k$ can be solved in $O(k^{1.5}+n+m)$ time.*

Proof.

By Proposition 4.2, $\triangle$-Enum parameterized by feedback edge number $k$ admits a constant-delay enum-advice kernel with at most $k$ edges. It can be computed in $O(n+m)$ time and the size of the advice is in $O(k)$. Itai and Rodeh [37, Theorem 3] showed that the number of triangles in a graph is upper-bounded by $m^{3/2}$ and that all triangles in a graph can be enumerated in $O(m^{3/2})$ time. Let $(G,k)$ be an input instance of $\triangle$-Enum parameterized by feedback edge number and let $I(G,k)$ be the kernel instance of the described enum-advice kernelization. Since $|I(G,k)|\in O(k)$, all solutions can be listed in $O(|I(G,k)|^{3/2})$ time and the number of triangles in both instances is in $O(k^{3/2})$. The statement of the theorem then follows directly from Lemma 3.6. ∎

4.1.2 Distance to $d$-Degenerate Graphs plus Maximum Degree

We next turn to the parameters distance to $d$-degenerate graphs and maximum degree. A graph is $d$-degenerate if each induced subgraph contains a vertex of degree at most $d$. The distance to $d$-degenerate graphs of a graph $G$ is the size of a minimum-cardinality vertex set $D$ such that $G-D$ is $d$-degenerate. This parameter generalizes several well-known parameters like vertex cover (distance to 0-degenerate graphs) and feedback vertex set (distance to 1-degenerate graphs). For any fixed $d$ the distance to $d$-degenerate graphs is $\mathsf{NP}$-hard to compute [46]. However, we can use existing linear-time constant-factor approximation algorithms for $d=0$ and $d=1$ [4]. Since a minimum feedback vertex set of a graph is always (and possibly much) smaller than its smallest vertex cover, it is natural to use this parameter rather than the vertex cover number if comparably good results can be shown for both parameters.

For larger values of $d$, one can use heuristics to compute small sets $D$ such that $G-D$ is $d$-degenerate. Notably, the quality of the heuristic only affects the running time but not the solution quality of the subsequent parameterized algorithm.

The distance to $d$-degenerate graphs is usually small in many applications such as social networks as they contain only few vertices with high degree [22]. Depending on the degree distribution at hand one can then choose the value of $d$ that gives the best overall running-time. (The running time of the corresponding algorithms usually has some trade-off between $d$ and the distance to $d$-degenerate graphs.)

Green and Bader [30] stated that Triangle Counting parameterized by the size of a vertex cover $V^{\prime}$ and the maximum degree $d_{\max}=\max(\{\deg(v)\mid v\in V^{\prime}\})$ of vertices in this vertex cover can be solved in $O(|V^{\prime}|\cdot d_{\max}^{2}+n)$ time. We will construct an algorithm which solves $\triangle$-Enum parameterized by the distance to $d$-degenerate graphs, provided that the respective set is given. Let $D$ be set of vertices such that $G-D$ is $d$-degenerate, where $G$ is the input graph. Let $\Delta_{D}$ be the maximum degree of a vertex in $D$ with respect to $G$. Our algorithm takes $O(|D|\cdot\Delta_{D}^{2}+n\cdot d^{2})$ time. Note that for each vertex cover $V^{\prime}$ it holds that $G-V^{\prime}$ is [math]-degenerate. Hence applying our algorithm with $d=0$ yields a running time of $O(|D|\cdot\Delta_{D}^{2}+n\cdot d^{2})=O(|D|\cdot\Delta_{D}^{2}+n)$. This matches the running time of Green and Bader’s algorithm. Consequently, our result generalizes the result by Green and Bader.

Proposition 4.4**.**

$\triangle$-Enum* parameterized by distance to $d$-degenerate graphs and maximum degree $\Delta_{D}$ in a set $D$ such that $G-D$ is $d$-degenerate is solvable in ${O(|D|\cdot\Delta_{D}^{2}+n\cdot d^{2})}$ time provided that the set $D$ is given.*

Proof.

Let $D$ be a set such that $G-D$ is $d$-degenerate and let the maximum degree in $D$ be $\Delta_{D}=\max(\{\deg_{G}(v)\mid v\in D\})$. We show how to list all triangles in $G$ in ${O(|D|\cdot\Delta_{D}^{2}+n\cdot d^{2})}$ time in two steps.

In the first step, list all triangles which do not contain any vertices in $D$. To this end, compute the $d$-degenerate graph $G^{\prime}=G-D$ and list all triangles contained in $G^{\prime}$ in $O(n\cdot d^{2})$ time [13].

In the second step, list all triangles with at least one vertex contained in $D$. To this end, in linear time fix an arbitrary strict order $<_{a}$ on $V(G)$ such that $v<_{a}w$ for all $v\in D,w\in V(G^{\prime})$. For each $u\in D$, iterate over all of the at most $\Delta_{D}^{2}$ possible pairs of neighbors $v,w\in N(u)$. For each pair $v,w\in N(u)$, check in constant time whether (i) $\{v,w\}\in\leavevmode\nobreak\ E(G)$ and (ii) $u<_{a}v<_{a}w$, and list the triangle if both conditions are met. Let $\{x,y,z\}$ form a triangle in $G$ with at least one vertex in $D$, and without loss of generality let $x<_{a}y<_{a}z$. Then $x\in D$, and only in the iteration when $x$ is chosen from $D$ conditions (i) and (ii) are met and hence $\{x,y,z\}$ is listed. It follows that in the second step all triangles with at least one vertex in $D$ are enumerated exactly once in $O(|D|\cdot\Delta_{D}^{2})$ time. ∎

Using the above ideas, we also provide an enum-advice kernel for $\triangle$-Enum parameterized by distance to $d$-degenerate graphs and the maximum degree in the deletion set $D$.

Observation 4.5**.**

$\triangle$-Enum* parameterized by distance to $d$-degenerate graphs and maximum degree $\Delta_{D}$ in a set $D$ such that $G-D$ is $d$-degenerate admits a constant-delay enum-advice kernel provided that the distance to $d$-degenerate graphs deletion set $D$ is given. The kernel is of size $O(|D|\cdot\Delta_{D}\cdot d)$ and can be computed in $O(n\cdot d^{2}+|D|\cdot\Delta_{D})$ time.*

Proof.

The main idea is to only compute the first step of the algorithm in the proof of Proposition 4.4. Store in the advice all the triangles that are found in the process such that at least one vertex of the triangle has no neighbor in $D$. (In this way, we avoid double counting by having a triangle in the advice and in the kernel.) This first step takes $O(n\cdot d^{2})$ time. Then, the kernel contains the subgraph induced by $D$ and all neighbors of vertices in $D$. The kernel can be computed in $O(n+m)\subseteq O(n\cdot d+|D|\cdot\Delta_{D})$ time and the resulting graph contains at most $|D|\cdot(\Delta_{D}+1)$ vertices, at most $|D|\cdot\Delta_{D}$ edges with at least one endpoint in $D$, and at most $|D|\cdot\Delta_{D}\cdot d$ edges with no endpoint in $D$ since $G-D$ is $d$-degenerate. ∎

4.1.3 Distance to $d$-Degenerate Graphs

We next present an enum-advice kernel for $\triangle$-Enum parameterized by distance to $d$-degenerate graphs. Recall that the distance to $d$-degenerate graphs of a graph $G$ is the size of a minimum-cardinality vertex set $D$ such that each induced subgraph of $G-D$ contains a vertex of degree at most $d$ (that is, $G-D$ is $d$-degenerate). The ideas for the kernel regarding the distance to $d$-degenerate graphs are a little bit different than the ones for 4.5; we will, however, start similarly and enumerate all triangles in the $d$-degenerate subgraph and store them in the advice.

Theorem 4.6**.**

$\triangle$-Enum* parameterized by distance to $d$-degenerate graphs admits a constant-delay enum-advice kernel provided that the distance deletion set $D$ to $d$-degenerate graphs is given. The kernel contains at most $|D|+2^{|D|}+3$ vertices and can be computed in $O(n\cdot(d+1)\cdot(|D|+d))$ time.*

Proof.

Let $G$ be an instance of $\triangle$-Enum and let $k=|D|$ be the parameter. Construct the enum-advice kernel $(I(G,k),A(G,k))$ as follows. To this end, we call ${(G_{I},k^{\prime})\mathrel{\vbox{\hbox{\scriptsize.}\hbox{\scriptsize.}}}=I(G,k)}$ and $A\mathrel{\vbox{\hbox{\scriptsize.}\hbox{\scriptsize.}}}=A(G,k)$.

First, compute the $d$-degenerate graph $G^{\prime}=G-D$. The graph $G^{\prime}$ contains exactly those triangles in $G$ that do not contain any vertices in $D$. Using a result of Chiba and Nishizeki [13, Theorem 1], compute the set of triangles in $G^{\prime}$ in $O(m\cdot d)$ time. Next, compute all triangles with exactly one vertex in $D$. To this end, compute the degeneracy ordering in linear time [47], iterate over all $v\in D$, $u\in N(v)\setminus D$, and the at most $d$ neighbors of $u$ that are ordered after $u$ in the degeneracy order, and list all triangles found. By this, all triangles in $G$ containing exactly one vertex in $D$ are found in $O(k\cdot n\cdot d)$ time. Altogether, we can compute the set $T_{1}$ of all triangles in $G$ with at most one vertex in $D$ in $O(n\cdot d\cdot(k+d))$ time.

Delete all edges which have no endpoint in $D$ as they cannot be part of any further triangles. Next, compute all modules in the current graph, that is, a partition $\mathcal{P}$ of the vertices according to their neighbors, using partition refinement in $O(n+m)$ time [32].

For each non-empty part $P\in\mathcal{P}$ pick one vertex $v_{P}\in P$ and store a function $M$ such that $M(v_{P})=P\setminus D$. Put all vertices in $D$, all of the chosen vertices, and all edges induced by these vertices into $G_{I}$. Add three new vertices $a,b,c$ to $G_{I}$ and if ${T_{1}\neq\emptyset}$, then add three new edges $\{a,b\},\{a,c\},\{b,c\}$. Note that all edges have an endpoint in $D^{\prime}=D\cup\{a,b\}$ and thus $D^{\prime}$ is a deletion set to $d$-degenerate graphs for every $d$. Complete the construction by setting $k^{\prime}=|D^{\prime}|$ and $A=(T_{1},M,\{a,b,c\})$. Note that $G_{I}$ contains at most $k+2^{k}+3$ vertices (K1). Observe that since ${m\in O(n\cdot(k+d))}$, the kernel can be constructed in ${O(n\cdot d\cdot(k+d))}$ time. For $x_{1},x_{2},x_{3}\in V(G_{I})$, define the function $f$ as

[TABLE]

Next, we prove that the algorithm fulfills all conditions of Definition 3.4.

Observe that $G_{I}$ is isomorphic to a subgraph of $G$ and, hence, if there is a triangle $G_{I}$, then there is a triangle in $G$. Assume that there is a triangle $X$ with vertices $\{x_{1},x_{2},x_{3}\}$ in $G$. If $X$ contains at most one vertex in $D$, then $T_{1}\neq\emptyset$ and thus there is the triangle formed by $\{a,b,c\}$ in $G_{I}$. Otherwise, $X$ contains at least two vertices in $D$. Assume without loss of generality that $x_{2},x_{3}\in D$. If $x_{1}$ is in $D$, then $X$ is also contained in $G_{I}$. Otherwise, there is a vertex $v$ in $G_{I}$ such that $x_{1}\in M(v)$. Since $\{x_{1},x_{2},x_{3}\}$ forms a triangle in $G$, it follows that $\{v,x_{2},x_{3}\}$ forms a triangle in $G$ and $G_{I}$. Hence, condition (K2) (of Definition 3.4) is fulfilled.

Next we discuss the condition (K3). We will prove that for each triangle ${X=\{x_{1},x_{2},x_{3}\}}$ in $G$ there is a unique solution $w\in\mathtt{Sol}(G_{I},k^{\prime})$ such that $X\in f(w,A)$ (K3b). If $X$ contains at most one vertex in $D$, then by construction $X\in f(\{a,b,c\},A)$. Since $G_{I}$ contains only edges with an endpoint in $D$, no triangle $\{v_{1},v_{2},\allowbreak v_{3}\}$ where $v_{1}\in M(x_{1})$, $v_{2}\in M(x_{2})$, and ${v_{3}\in M(x_{3})}$ is contained in $G_{I}$. Thus, $\{a,b,c\}$ is the only triangle $T$ such that ${X\in f(T,A)}$. If $X$ contains at least two vertices $x_{2},x_{3}\in D$, then there exists a vertex $v$ in $G_{I}$ such that $x_{1}\in M(v)$ and the triangle $\{v,x_{2},x_{3}\}$ is contained in $G$. By construction, the triangle $\{v,x_{2},x_{3}\}$ is also contained in $G_{I}$ and $X\in f(\{v,x_{2},x_{3}\},A)$. Since $X\notin T_{1}$, it follows $X\notin f(\{a,b,c\},A)$.

Next we show that for any two triangles $p=\{u_{1},u_{2},u_{3}\}$ and $q=\{v_{1},v_{2},v_{3}\}$ in $G_{I}$, it holds that $f(p,A)\cap f(q,A)=\emptyset$ (K3a).

If either $p$ or $q$ is $\{a,b,c\}$ (without loss of generality $p=\{a,b,c\}$), then by definition $f(p,A)$ only contains triangles with at most one vertex in $D$ and $f(q,A)$ only contains triangles with at least two vertices in $D$ and thus ${f(p,A)\cap f(q,A)=\emptyset}$.

If neither $p$ nor $q$ is $\{a,b,c\}$, then both of them only contain vertices from the original graph $G$. As $p\neq q$, assume without loss of generality that $u_{1}\notin q$ and $v_{1}\notin p$. By construction all triangles in $f(p,A)$ contain one vertex in $M(u_{1})$ and all triangles in $f(q,A)$ contain one vertex in $M(v_{1})$. As shown above, $M(u_{1})$ ($M(v_{1})$, respectively) only contains $u_{1}$ ($v_{1}$) and vertices that have the same neighbors as $u_{1}$ ($v_{1}$) in $D$. Hence, no triangle in $f(p,A)$ ($f(q,A)$ respectively) contains a vertex in $M(v_{1})$ ($M(u_{1})$) and thus $f(p,A)\cap f(q,A)=\emptyset$.

Each triangle in $\{\{v_{1},v_{2},v_{3}\}\mid v_{1}\in M(x_{1})\land v_{2}\in M(x_{2})\land v_{3}\in M(x_{3})\}$ and in $T_{1}$ can be returned with constant delay between generating two successive solutions (K3c).

Overall, the time needed to compute the kernel $(I(G,|D|),A(G,|D|))$ is upper-bounded by $O(n\cdot d\cdot(|D|+d)+|D|+m)=O(n\cdot(d+1)\cdot(|D|+d))$. The equality holds since $m\in O(n\cdot(|D|+d))$. ∎

To the best of our knowledge, there is no algorithm that solves $\triangle$-Enum parameterized by distance to $d$-degenerate graphs within $O(n\cdot d^{2}+|D|\cdot\Delta_{D})$ time. All solutions can be reconstructed in constant-delay time and there is no known algorithm that solves $\triangle$-Enum in constant-delay time (and it seems unlikely that such an algorithm exists).

Using Lemma 3.6 and Theorem 4.6 we get the following result.

Corollary 4.7**.**

$\triangle$-Enum* parameterized by distance to $d$-degenerate graphs is solvable in $O(n\cdot(d+1)\cdot(|D|+d)+2^{3|D|}+\operatorname{\#T})$ time provided that the vertex-deletion set $D$ to $d$-degenerate graphs is given.*

Proof.

By Theorem 4.6, $\triangle$-Enum parameterized by the distance to $d$-degenerate graphs (provided that the set $D$ such that $G-D$ is $d$-degenerate is given) admits a constant-delay enum-advice kernel with size $O(2^{2|D|})$ that can be computed in $O(n\cdot(d+1)\cdot(|D|+d))$ time. Hence, all triangles in the kernel instance can be found in $O(2^{3|D|})$ time [37]. Since the delay is constant and the number of triangles in both graphs is at most $\operatorname{\#T}$, we can compute all triangles in the original instance from all solutions in the kernel in $O(\operatorname{\#T})$ time. Thus, by Lemma 3.6, $\triangle$-Enum is solvable in ${O(n\cdot(d+1)\cdot(|D|+d)+2^{3|D|}+\operatorname{\#T})}$ time parameterized by distance to $d$-degenerate graphs assuming that the set $D$ is given. ∎

4.2 Parameters Incomparable with Degeneracy

In this section we present results on parameters that are unrelated to the degeneracy. Again, we first describe the parameters and then turn to our results.

In Section 4.2.1, we consider the vertex-deletion distance to cographs, bipartite, or chordal graphs. A graph is bipartite if its set of vertices can be partitioned into two sets such that no edge in the graph has both endpoints in one of the sets. A graph is called chordal if it does not contain induced cycles of length at least four. A graph is called a cograph if it contains no induced path with four vertices ($P_{4}$).

We show below that enumerating all triangles is easy if the input graph falls into one of the three graph classes. Thus, the three parameters mentioned above are natural candidates for a “distance-to-triviality” approach [31]. Furthermore, all three parameters are upper-bounded by the vertex cover number. The vertex cover number allows for tractability results (see Section 4.1). Thus, aiming at generalizing the tractability result, we arrive at the study of these parameters. Moreover, distance to bipartite graphs and distance to cographs are lower-bounded by parameters for which we know intractability, see Figure 4. Thus, we also investigate the limits of how far we can generalize the tractability results.

Distance to cographs lower-bounds the cluster vertex number—a parameter advocated by Doucha and Kratochvíl [19] by proving that several basic graph-theoretic problems parameterized by it are fixed-parameter tractable (note that it lies between the vertex cover number and clique-width). Moreover, given a graph $G$, we can determine in linear time whether $G$ is a cograph and, if this is not the case, return an induced $P_{4}$ [10, 14]. This implies that in $O(k\cdot(m+n))$ time, with $k$ being the distance to cographs, we can compute a set $K\subseteq V$ of size at most $4k$ such that $G-K$ is a cograph. However, we are not aware of (parameterized) linear-time constant-factor approximation algorithms for distance to bipartite or distance to chordal.

In Section 4.2.2, we consider the parameter clique-width. Since treewidth is lower-bounded by degeneracy, we know that there is an $O(\tau\cdot m)$-time algorithm for $\triangle$-Enum, where $\tau$ is the treewidth of the input graph. A parameter lower bounding treewidth in the parameter hierarchy is clique-width $k$ (it holds that $k\leq 2^{\tau+1}+1$ and $k$ can be arbitrarily small compared to $\tau$ [16]). Moreover, clique-width also lower-bounds distance to cograph. Thus, we study clique-width as it lies on the “border to tractability” of $\triangle$-Enum.

4.2.1 Distance to Bipartite Graphs, Chordal Graphs, or Cograph

We give linear-time FPT algorithms for $\triangle$-Enum with respect to the distance to bipartite, distance to chordal, and distance to cographs, respectively. Our main results in this section are summarized in the following.

Theorem 4.8**.**

$\triangle$-Enum* is solvable in $O(n+m\log n\cdot|K|+M)$ time*

1. (a)

with $M=0$, when parameterized by the distance $k$ to bipartite graphs, provided that the deletion set is given; 2. (b)

with $M=\operatorname{\#T}$, when parameterized by the distance $k$ to chordal graphs, provided that the deletion set is given; 3. (c)

with $M=\operatorname{\#T}$, when parameterized by the distance $k$ to cographs.

In order to prove Theorem 4.8, we provide a general lemma which can be used to solve $\triangle$-Enum with a given (vertex) deletion set to some graph class $\Pi$ if all triangles in $\Pi$ can be enumerated efficiently.

Lemma 4.9**.**

Let $\Pi$ be some graph class and let $f_{\Pi}(n,m)$ be the time required to solve $\triangle$-Enum on graphs in $\Pi$. Then, $\triangle$-Enum with a given vertex-deletion set $K$ to $\Pi$ is solvable in $O(m\cdot|K|+n+f_{\Pi}(n,m))$ time.

Proof.

Let $K$ be a set of vertices such that $G^{\prime}=G-K$ is a graph contained in $\Pi$. By definition, all triangles within $G^{\prime}$ can be listed in $O(f_{\Pi}(n,m))$ time. All triangles with at least one vertex in $K$ can be listed in $O(m\cdot|K|+n)$ time by the following algorithm. Read the whole input and fix an arbitrary linear order $\leq_{a}$ of the vertices in $K$ in $O(n+m)$ time. Check for each edge $\{u,w\}\in E(G)$ and each vertex $v\in K$ whether $\{u,v,w\}$ is a triangle and for all $x\in\{u,w\}\cap K$ it holds that $v\leq_{a}x$. This can be done for all edges and one vertex $v\in K$ in $O(m)$ time by first marking all neighbors of $v$, then check for each edge whether both endpoints are marked and finally remove all markings (by again iterating over all neighbors of $v$). If both conditions hold, then list $\{u,v,w\}$ as a new triangle. We prove that this algorithm lists all triangles with at least one vertex in $K$ exactly once. Since $v\in K$ holds, this algorithm does not list any triangles which do not contain vertices in $K$. Let $\{a,b,c\}$ be an arbitrary triangle and let $a$ be in $K$. This triangle is found at least once as $\{b,c\}\in E$ and $a\in K$ holds. If for all $x\in\{b,c\}$ it holds that $x\notin K$ or $a\leq_{a}x$, then this triangle is listed in the iteration where $v=a$ and $\{u,w\}=\{b,c\}$. Otherwise, $b\leq_{a}a$ or $c\leq_{a}a$ holds. Without loss of generality, let $b$ be such that $b\leq_{a}y$ with $y\in\{a,b,c\}\cap K$. Then $\{a,b,c\}$ is listed in the iteration where $v=b$ and $\{u,w\}=\{a,c\}$ holds. There are $m\cdot|K|$ iterations and each iteration takes $\log n$ time. Thus, $\triangle$-Enum parameterized by deletion set to $\Pi$ is solvable in $O(m\cdot|K|+n)$ time. ∎

Theorem 4.8 follows immediately from applying Lemma 4.9 with $\Pi$ being the class of bipartite graphs, of chordal graphs, and of cographs. To this end, in the remainder of this section, we provide the remaining requirements to apply Lemma 4.9, that is, we give the running times in which $\triangle$-Enum is solvable on bipartite graphs (4.10), chordal graphs (Proposition 4.11), and cographs (Proposition 4.12).

Distance to Bipartite Graphs

Since bipartite graphs do not contain cycles of odd length and thus are triangle-free, $\triangle$-Enum is solvable in constant time on bipartite graphs after reading the input.

Observation 4.10**.**

$\triangle$-Enum* is solvable in $O(n+m)$ time on bipartite graphs.*

Distance to Chordal Graphs

For each chordal graph there is a perfect elimination order $\leq_{p}$ of the vertices which can be computed in linear time. That is, for each vertex $v$ all neighbors $w$ of $v$ with $v\leq_{p}w$ form a clique. We will use this to find all triangles in chordal graphs in $O(\operatorname{\#T}{}+\,n+m)$ time and thus by Lemma 4.9 solve $\triangle$-Enum given a deletion set $K$ to chordal graphs in $O(\operatorname{\#T}{}+\,n+m\log n\cdot|K|)$ time. Recall that $\operatorname{\#T}{}$ is the number of triangles in $G$. Note that a clique containing $n$ vertices contains $O(n^{3})$ triangles and that graphs consisting of only one large clique are chordal. We therefore cannot avoid the term $\operatorname{\#T}{}$ in the running time.

Proposition 4.11**.**

$\triangle$-Enum* is solvable in ${O(\operatorname{\#T}{}+\,n+m)}$ time on chordal graphs.*

Proof.

Compute a perfect elimination ordering in $O(n+m)$ time. Next, list all triangles containing the first vertex in this ordering and delete it afterwards. Proceed in this manner until no vertex is left.

Let $v$ be the vertex at the first position in the perfect elimination ordering in some iteration. Listing all triangles containing $v$ can be done as follows. As $v$ is the first vertex in the ordering, there are no vertices before $v$ and, by the definition of a perfect elimination ordering, $N(v)$ forms a clique. Hence, $v$ combined with any two of its neighbors forms a triangle. Thus, we list all triangles of the form $\{v,x,y\}$ with $x\in N(v)$, $y\in N(v)$, and $x\neq y$. Once all of these triangles are listed, $v$ is not contained in any triangle not being listed and hence one can delete it. ∎

Distance to Cograph

We now show how to enumerate all triangles in a cograph. To this end, we need the following notation. Every cograph has a binary cotree representation which can be computed in linear time [14]. A cotree is a rooted tree in which each leaf corresponds to a vertex in the cograph and each inner node either represents a disjoint union or a join of its children. A join of two graphs $(V_{1},E_{1}),(V_{2},E_{2})$ with $V_{1}\cap V_{2}=\emptyset$ is the graph $(V_{1}\cup V_{2},E_{1}\cup E_{2}\cup\{\{x,y\}\mid x\in V_{1}\land y\in V_{2}\})$. We will use these representations to find all triangles in cographs in $O(\operatorname{\#T}{}+n+m)$ time, where $\operatorname{\#T}{}$ is the number of triangles in $G$. Note that one can compute a set $K$ of size at most $4k$ such that $G-K$ is a cograph, where $k$ is the size of a minimum set $K^{\prime}$ such that $G-K^{\prime}$ is a cograph, in $O(k\cdot(n+m))$ time.

Proposition 4.12**.**

$\triangle$-Enum* is solvable in $O(\operatorname{\#T}{}+n+m)$ time on cographs.*

Proof.

Consider a dynamic program which stores for each node $p$ in the cotree all vertices $V(p)$, all edges $E(p)$ and all triangles $T(p)$ in the corresponding subgraph of $G$. This can be done as follows:

Let $q_{1},q_{2}$ be the children of an inner node $p$ in the cotree.

• •

A single leaf node has one vertex and no edges or triangles.

• •

A union node has vertices $V(q_{1})\cup V(q_{2})$, edges $E(q_{1})\cup E(q_{2})$, and triangles $T(q_{1})\cup T(q_{2})$.

• •

A join node has

[TABLE]

That is, a join node contains all edges the two children contain and all possible edges between vertices of them. A join node contains all triangles its two child-nodes contain and one triangle for each edge $\{y,z\}$ of one of its children and a vertex $x$ of the other, because edges $\{x,y\}$ and $\{x,z\}$ are in $E$ and therefore $\{x,y,z\}$ is a triangle.

We will first prove that all triangles are enumerated that way and afterwards we will analyze the running time of the dynamic program.

Let $\{a,b,c\}$ be any triangle in the cograph. We will prove that there is at least one node $p$ in the cotree with $\{a,b,c\}\in T(p)$. As each inner node keeps the triangles from its children, it follows that $\{a,b,c\}\in T(r)$ when $r$ is the root node of the cotree. Let without loss of generality be $p$ the least common ancestor of $a,b,$ and $c$, and let $q_{1},q_{2}$ be the two children of $p$. As neither $\{a,b,c\}\in V(q_{1})$ nor $\{a,b,c\}\in V(q_{2})$, let us assume without loss of generality that $a\in V(q_{1})$ and $b,c\in V(q_{2})$. It holds that $\{b,c\}\in E(q_{2})$ because there is an edge between $b$ and $c$ and they are both descendants of $q_{2}$. The node $p$ has to be a join node as $\{a,b\},\{a,c\}\in E$ and $p$ is by definition the least common ancestor. By definition it holds that $\{\{x,y,z\}\mid x\in V(q_{1})\land\{y,z\}\in E(q_{2})\}\subseteq T(p)$. It follows that $\{a,b,c\}\in T(p)$. Note that $\{a,b,c\}$ is only computed once in the least common ancestor node $p$ and then passed to the parent node. Hence, $T(r)$ only contains $\{a,b,c\}$ once and thus listing all triangles in $T(r)$ solves $\triangle$-Enum.

We will now analyze the running time. There are $n$ leaf nodes in the cotree each of which require a constant amount of time to compute. There are at most $n-1$ union nodes each of which only require a constant amount of time as they only need to point on their children’s values. There are at most $n-1$ join nodes. Each edge and triangle is only added once and all other values do not need to be recomputed. A pointer to the edges and triangles in the child nodes is enough and only requires a constant amount of time to be set. Altogether, the global running time of this algorithm is in $O(\operatorname{\#T}{}+n+m)$. ∎

4.2.2 Clique-width

We next turn to the parameter clique-width as it is incomparable to the degeneracy and upper-bounded by two parameters allowing for linear-time FPT algorithms: the distance to cographs (Proposition 4.12) and treewidth (as treewidth upper-bounds the degeneracy).

The clique-width of a graph $G$ is the minimum number $k$ such that $G$ can be constructed using a $k$-expression. A $k$-expression consists of four operations which use $k$ labels [17]. The operations are the following.

• •

Creating a new vertex with some label $i$.

• •

Disjoint union of two labeled graphs.

• •

Edge insertion between every vertex with label $i$ to every vertex with label $j$ for some labels $i\neq j$.

• •

Renaming of label $i$ to $j$ for some $i,j$.

Let $V_{1}\subseteq V$ be a set of vertices. A twin class in $V_{1}$ is a set $V^{\prime}\subseteq V_{1}$ of vertices such that every vertex in $V\setminus V_{1}$ either has all vertices in $V^{\prime}$ as its neighbors or none of them. The set $V_{1}$ is called an $\ell$-module if it can be partitioned into at most $\ell$ twin classes. Let $B$ be a rooted full binary tree whose leaves are in bijection to the vertices in $V$. For each inner node $p$ in $B$ let $V_{p}\subseteq V$ be the set of all vertices in $G$ whose corresponding nodes in $B$ are in the induced subtree of $B$ rooted at $p$. If for each inner node $p$ in $B$ the set $V_{p}$ is an $\ell$-module, then $B$ is an $\ell$-module decomposition. We will use this $\ell$-module decomposition to construct a dynamic program to solve $\triangle$-Enum parameterized by some $k$-expression in ${O(n^{2}+k^{2}\cdot n+\operatorname{\#T}{})}$ time.

We leave open whether $\triangle$-Enum parameterized by clique-width $k$ admits a linear FPT algorithm. Our results suggest that the parameters clique-width and average degree form the border case between parameters admitting linear FPT algorithms and those that are GP-hard.

Theorem 4.13**.**

$\triangle$-Enum* parameterized by clique-width is solvable in $O(n^{2}+n\cdot k^{2}+\operatorname{\#T}{})$ time, provided that a $k$-expression of the input graph is given.*

Proof.

Recall that $\operatorname{\#T}{}$ is the number of triangles in $G$. Bui-Xuan et al. [11, Lemma 3.2] proved the following: First, given a $k$-expression tree $B$ of $G$ one can compute in overall $O(n^{2})$ time for every node $u$ in $B$ the partition of $V_{u}$ into its twin classes $Q_{u}(1),\ldots,Q_{u}(h_{u})$ where $V_{u}$ is the set of vertices corresponding to the leaves of the subtree of $B$ rooted at $u$. Second, the maximum number $h_{u}$ of twin classes for each node $u$ in $B$ is at most $k$. Third, $B$ can be modified such that it becomes a full binary tree and thus combined with the twin classes becomes a $k$-module decomposition of $G$. Fourth, the $k$-module decomposition has only a single twin class in the root node and each twin class of a node $u$ in $B$ is fully contained in one of the twin classes of the parent $v$ of $u$. We use these statements in our algorithm.

We next describe which information is stored in our dynamic program. First, store the information that all vertices in $Q_{u}(i)$ are contained in the twin class $Q_{v}(b)$ by adding $i$ to a set $M_{u,b}$.

Next, for each node $v$ in $B$ store $Q_{v}(1),\ldots,Q_{v}(h_{v})$, the twin classes of $v$ (which are already computed), the set $E^{v}_{i,j}$ of all edges between vertices in twin classes $Q_{v}(i)$ and $Q_{v}(j)$ $(1\leq i,j\leq h_{v})$, and the set $LT^{v}$ of all triangles formed by vertices in $V_{v}$. Denote by $F_{u,a,w,b}$ the set of all edges with one endpoint in $Q_{u}(a)$ and one in $Q_{w}(b)$ where $u$ and $w$ have the same parent in $B$, formally, $F_{u,a,w,b}=\{\{x,y\}\mid x\in Q_{u}(a)\land y\in Q_{w}(b)\}\cap E$.

Note that by the definition of twin classes, either all vertices of the twin classes of two nodes with the same parent in $B$ are pairwise connected or none of them are.

The dynamic program is defined as follows. A leaf node $v$ in $B$ has an empty set of triangles and only empty edge sets. An inner node $v$ with children $u,w$ has for each ${1\leq i,j\leq h_{v}}$ an edge set

[TABLE]

and a set of triangles

[TABLE]

where

[TABLE]

We next analyze the running time and then the correctness of the dynamic program. The table entries for each of the $n$ leaves in $B$ can be computed in constant time. For each of the $n-1$ inner nodes, at most $k^{2}$ sets of edges have to be computed, each of which is formed out of two parts: edges already stored in the children and edges between vertices of different children. The former requires $O(k^{2})$ time per node as it can be seen as a list of pointers to the children’s sets of edges. The latter requires $O(m)$ global time as each edge is only added once. Hence, the edge sets of all nodes can be computed in $O(n\cdot k^{2}+m)$ time. The list of triangles is a list containing two pointers to its children’s list of triangles and a third list of new triangles. As each triangle is only added once, all lists can be computed in $O(\operatorname{\#T}+n)$ time.

We will prove that each triangle $\{x,y,z\}$ is found in the least ancestor node $p$ of $x$, $y$, and $z$. As each node in $B$ references the triangles of its children, $\{x,y,z\}$ is passed on to the root node in $B$. Note that each node in $B$ only computes those new triangles which have one vertex in the subtree rooted in one child node and two vertices in the subtree rooted in the other child node. Thus each triangle is computed at most once. Let $q$ and $r$ be the children of $p$ and let without loss of generality be $x\in Q_{q}(s),y\in Q_{q}(t)$ and $z\in Q_{r}(u)$. Since $\{x,z\},\{y,z\}\in E$, it holds that $F_{q,s,r,u}\neq\emptyset$ and $F_{q,t,r,u}\neq\emptyset$. Moreover, it holds that $\{x,y\}\in E^{q}_{s,t}$ because $x\in Q_{q}(s),y\in Q_{q}(t)$, and $\{x,y\}\in E$. Hence, $\{x,y,z\}$ is contained in

[TABLE]

which is a subset of $LT_{q,q,r}$. Since $LT_{q,q,r}\subseteq LT^{p}$, $\{x,y,z\}$ is found in node $p$. ∎

5 Conclusion

Employing the framework of FPT-in-P analysis [28], we provided novel notions and insights concerning potentially faster algorithms for enumerating (and detecting) triangles in undirected graphs. One the one hand, it remains to be seen whether General-Problem-hardness is an appropriate notion for intractability within the field of FPT in P. On the other hand, so far there is still little work on kernelization in the context of enumeration problems; we hope that the notion of enum-advice kernels can be used to further develop this area of research.

As previously observed by Ortmann and Brandes [51], the parameterized algorithm of Chiba and Nishizeki [13] despite its age is still very competitive. Experiments revealed that their algorithm enumerated all triangles in social networks with several hundred thousand vertices within a few seconds. Our algorithms for the parameter distance to $d$-degenerate graphs had to perform less operations for small values of $d$; we were, however, not able to beat the actual running time of the algorithm by Chiba and Nishizeki [13]. An analysis revealed that their algorithm uses main memory of modern computers with their memory hierarchy more efficiently. In particular, our algorithm accesses data that is scattered throughout the memory. We conclude that further practical improvement for $\triangle$-Enum should include aspects of memory-efficiency in the algorithm design process. Independent to our work, a first step into this direction has already been done by Hu et al. [33].

It remains open to study whether our exponential-size kernel for the parameter “distance to $d$-degenerate graphs” (see Theorem 4.6) can be improved in terms of size and running time. On a more general scale, note that triangles are the smallest non-trivial cliques as well as cycles. Can one generalize our findings to these two different settings when increasing the subgraph size? Finally, we mention that following the FPT-in-P route might be an attractive way to “circumvent” lower bound results for other polynomial-time solvable problems. To this end, a systematic exploration of parameter spaces (cf. Sorge and Weller [56] or Figure 4) and parameter combinations [50] seems beneficial.

Acknowledgement

We are grateful to Philipp Zschoche for providing the practical insights and preliminary experiments. We thank Mark Ortmann for fruitful discussions on obstacles for practical algorithms. Finally, we are grateful to two anonymous reviewers of Journal of Computer and System Sciences whose constructive feedback helped to significantly improve the presentation.