Triangle Finding and Listing in CONGEST Networks

TL;DR

This paper introduces the first sublinear round complexity algorithms for triangle detection and listing in the standard CONGEST network model, advancing distributed graph algorithms.

Contribution

It presents the first sublinear algorithms for triangle finding and listing in the CONGEST model, with specific complexities and a matching lower bound.

Findings

Triangle finding algorithm with $O(n^{2/3}( ext{log} n)^{2/3})$ rounds.

Triangle listing algorithm with $O(n^{3/4} ext{log} n)$ rounds.

Lower bound of $ ilde{ ext{Omega}}(n^{1/3})$ rounds for triangle listing.

Abstract

Triangle-free graphs play a central role in graph theory, and triangle detection (or triangle finding) as well as triangle enumeration (triangle listing) play central roles in the field of graph algorithms. In distributed computing, algorithms with sublinear round complexity for triangle finding and listing have recently been developed in the powerful CONGEST clique model, where communication is allowed between any two nodes of the network. In this paper we present the first algorithms with sublinear complexity for triangle finding and triangle listing in the standard CONGEST model, where the communication topology is the same as the topology of the network. More precisely, we give randomized algorithms for triangle finding and listing with round complexity $O(n^{2/3}(\log n)^{2/3})$ and $O(n^{3/4}\log n)$, respectively, where $n$ denotes the number of nodes of the network. We also show a lower bound $\Omega(n^{1/3}/\log n)$ on the round complexity of triangle listing, which also holds for the CONGEST clique model.

Tables

Table 1. Table 1: Prior results on the round complexity of distributed triangle finding and listing and our new results, where n 𝑛 n denotes the number of nodes in the network.

Paper	Time Bound	Problem	Model
Dolev et al. [8]	$O\left(n^{1/3}{\left(\log n\right)}^{2/3}\right)$	Listing	CONGEST clique\bigstrut
	$O\left(d_{\mathrm{𝑚𝑎𝑥}}^3/n\right)$
Censor-Hillel et al. [6]	$O\left(n^{0.1572}\right)$	Finding	CONGEST clique \bigstrut
This paper (Theorem 1)	$O\left(n^{2/3}{\left(\log n\right)}^{2/3}\right)$	Finding	CONGEST \bigstrut
This paper (Theorem 2)	$O\left(n^{3/4}\log n\right)$	Listing	CONGEST \bigstrut
Drucker et al. [9]	$\Omega \left(\frac{n}{e^{\sqrt{\log n}}\log n}\right)$ (conditional)	Finding	CONGEST broadcast \bigstrut
Pandurangan et al. [29]	$\Omega \left(\frac{n^{1/3}}{{\log }^{3}n}\right)$	Listing	CONGEST clique \bigstrut
This paper (Theorem 3)	$\Omega \left(\frac{n^{1/3}}{\log n}\right)$	Listing	CONGEST clique \bigstrut

Equations

$$\#(\{j,k\})=\Big{|}\left\{l\in V\>|\>\{j,l\}\in E\textrm{ and }\{k,l\}\in E\right\}\Big{|}.$$

$$\Pr\left[h(x)=h(x^{\prime})=y\bigwedge\Big{|}H(y)\Big{|}\leq 4\left(2+\frac{|\mathcal{X}|-2}{|\mathcal{Y}|}\right)\right]\geq\frac{3}{4|\mathcal{Y}|^{2}}.$$

$$\displaystyle E\Big{[}|Z|\>|\>Z_{x}=Z_{x^{\prime}}=1\Big{]}$$

$$=2+\sum _{a\in \mathcal{X}\setminus \{x,x^{\prime }\}}E[Z_a|Z_x=Z_{x^{\prime }}=1]$$

$$=2+\frac{|\mathcal{X}|-2}{|\mathcal{Y}|}.$$

$$\mathrm{Pr}\left[|Z|>4\left(2+\frac{|\mathcal{X}|-2}{|\mathcal{Y}|}\right)|Z_x=Z_{x^{\prime }}=1\right]$$

$$\mathrm{Pr}\left[Z_x=Z_{x^{\prime }}=1\bigwedge |Z|\le 4\left(2+\frac{|\mathcal{X}|-2}{|\mathcal{Y}|}\right)\right]$$

$$=\mathrm{Pr}\left[|Z|\le 4\left(2+\frac{|\mathcal{X}|-2}{|\mathcal{Y}|}\right)|Z_x=Z_{x^{\prime }}=1\right]$$

$$\times \mathrm{Pr}[Z_x=Z_{x^{\prime }}=1]$$

$$\ge \frac{3}{4}\times \frac{1}{|\mathcal{Y}{|}^2},$$

$$\mathrm{Pr}\left[h_a(k)=h_a(l)=0\bigwedge |E_a^j\cup E_a^k|\le 8+\frac{4n}{\lfloor n^{\epsilon /2}\rfloor }\right]\ge \frac{3}{4n^{\epsilon }}.$$

$$\mathrm{Pr}\left[\bigcap _{a\in A}t\notin T_a\right]\le {\left(1-\frac{3}{4n^{\epsilon }}\right)}^{|A|}\le {\left(1-\frac{3}{4n^{\epsilon }}\right)}^{n^{\epsilon }}\le e^{-\Omega (1)}.$$

$$\Delta (X)=\mathcal{E}(V)\setminus \bigcup _{x\in X}\mathcal{E}(\mathcal{N}(x)),$$

$${\mathcal{S}}_U^X(j,k)$$

$$\mathcal{V}_{U,r}^{X}(j)=\big{\{}k\in U\>|\>\{j,k\}\in E\textrm{ and }\left|\mathcal{S}_{U}^{X}(j,k)\right|>r\big{\}}.$$

$$U\subseteq V$$

$$\#(\{j,l\})\ge 27n^{\epsilon }\log n.$$

$$\underset{X}{\mathrm{Pr}}\left[\{j,l\}\notin \bigcup _{x\in X}\mathcal{E}(\mathcal{N}(x))\right]\le {\left(1-\frac{1}{9n^{\epsilon }}\right)}^{27n^{\epsilon }\log n}\le \frac{1}{n^3}.$$

$$\#(\{j,l\})<27n^{\epsilon }\log n\text{ for any pair {j,l}∈Δ(X). }$$

$$\sum _{\begin{array}{c}(j,k)\in U\times U\\ \text{s.t. }\{j,k\}\in E\end{array}}\left|{\mathcal{S}}_U^X(j,k)\right|.$$

$$27|U{|}^2{n}^{\epsilon }\log n\ge \sum _{\begin{array}{c}(j,k)\in U\times U\\ \text{s.t. }\{j,k\}\in E\end{array}}\left|{\mathcal{S}}_U^X(j,k)\right|\ge \sum _{j\in U}\left|{\mathcal{V}}_{U,r}^X(j)\right|r,$$

$$27|U{|}^2{n}^{\epsilon }\log n\times \frac{1}{r^2}\le \frac{27|U|n^{1+\epsilon }\log n}{r^2}.$$

$$|X|+1+({\log }_2(n)+1)(r+r+1)=O(|X|+r\log n).$$

$$O(n^{1-\epsilon }+n^{(1+\epsilon )/2}\log n).$$

$$I(\mathbf{E};{\mathbf{T}}_i)$$

$$=H(\mathbf{E})-H(\mathbf{E}|{\mathbf{T}}_i)$$

$$=H(\mathbf{E})-\sum _{\{j,k\}\in \mathcal{E}}H({\mathbf{e}}_{\{j,k\}}|{\mathbf{T}}_i)$$

$$=H(\mathbf{E})-\sum _{\{j,k\}\in \mathcal{E}}\sum _{R\subseteq \mathcal{T}}H({\mathbf{e}}_{\{j,k\}}|{\mathbf{T}}_i=R)\cdot \mathrm{Pr}[{\mathbf{T}}_i=R]$$

$$=M-\sum _{R\subseteq \mathcal{T}}\sum _{\{j,k\}\in \mathcal{E}}H({\mathbf{e}}_{\{j,k\}}|{\mathbf{T}}_i=R)\cdot \mathrm{Pr}[{\mathbf{T}}_i=R]$$

$$=M-\sum _{R\subseteq \mathcal{T}}\sum _{\{j,k\}\in \mathcal{E}\setminus \mathcal{P}(R)}H({\mathbf{e}}_{\{j,k\}}|{\mathbf{T}}_i=R)\cdot \mathrm{Pr}[{\mathbf{T}}_i=R],$$

$$I(\mathbf{E};{\mathbf{T}}_i)$$

$$\ge \sum _{R\subseteq \mathcal{T}}|\mathcal{P}(R)|\cdot \mathrm{Pr}[{\mathbf{T}}_i=R]=E[|\mathcal{P}({\mathbf{T}}_i)|],$$

$$I(\mathbf{E};{\mathbf{T}}_{w(\mathbf{T})})\ge E[|P({\mathbf{T}}_{w(\mathbf{T})})|].$$

$$I(\mathbf{E};{\mathbf{T}}_{w(\mathbf{T})})\ge E[|\mathcal{P}({\mathbf{T}}_{w(\mathbf{T})})|]$$

$$=\sum _{R\subseteq \mathcal{T}}|P(R)|\cdot \mathrm{Pr}[{\mathbf{T}}_{w(\mathbf{T})}=R]$$

$$\ge \sum _{R\subseteq \mathcal{T},|R|\ge \frac{N}{16n}}|\mathcal{P}(R)|\cdot \mathrm{Pr}[{\mathbf{T}}_{w(\mathbf{T})}=R].$$

$$\ge \sum _{R\subseteq \mathcal{T},|R|\ge \frac{N}{16n}}\frac{\sqrt{2}}{3}{\left(\frac{N}{16n}\right)}^{2/3}\cdot \mathrm{Pr}[{\mathbf{T}}_{w(\mathbf{T})}=R]$$

Full text

1 Introduction

Background.

The most standard way of modeling distributed networks is to use graphs, where vertices and edges respectively correspond to computing entities (e.g., nodes or processes) and communication channels. The graphical structure of networks naturally motivates, both practically and theoretically, the study of graph algorithms, i.e., in-network solving of combinatorial graph problems for the own topology of the network. In the last twenty years, research on distributed complexity theory has successfully investigated many fundamental graph problems such as independent set [1, 4], dominating set [22, 21], coloring [25, 3], minimum spanning trees [14, 10, 11, 15, 32, 26] shortest paths [24, 23, 27, 19], max-flow and min-cut [17, 28, 16]. The seminal textbook by Peleg [31] provides a good overview of those achievements.

A high-level perspective on distributed graph algorithms classifies problems into two categories according to their locality characteristics. Problems like minimum spanning trees, shortest paths or max-flow/min-cut mentioned above are classified as global problems because some node must (indirectly) communicate with a node $D$-hop away, where $D$ denotes the diameter of the network, which requires $\Omega(D)$ rounds. Since any problem can be solved within $O(D)$ rounds by a naive centralized approach if the communication bandwidth of each channel is unlimited, technical challenges on global problems appear only in the model of limited-bandwidth channels, the so-called CONGEST communication model where each channel has only $O(\log n)$-bit bandwidth. On the other hand, many local problems, like independent set, dominating set or coloring allow distributed (approximate) solutions within $o(D)$ rounds. Besides the limited bandwidth, a significant difficulty when designing distributed algorithms for local problems often consists in breaking the symmetry between nearby nodes.

Triangle finding.

Triangle finding is an important counterpart of the perspective explained above. Since the distance-two information for a node $i$ is sufficient to find all triangles around $i$, it is a purely local task. Aggregating at each node the set of its 2-hop neighbors, however, takes $\Theta(d_{\mathit{max}})$ rounds in the CONGEST model, where $d_{\mathit{max}}$ denotes the maximum degree of the nodes. In the case of dense graphs, such an approach gives linear round complexity. In this sense, despite being a local problem, the underlying difficulty of triangle finding is similar to the difficulty encountered when working with global problems in the CONGEST model, that is, the lack of communication bandwidth. These particularities make triangle finding a difficult problem to handle with current techniques. As summarized in Table 1, recently some non-trivial upper bounds have been obtained by Dolev et al. [8] and then improved by Censor-Hillel et al. [6], but these upper bounds hold only in the much stronger CONGEST clique model (where at each round messages can even be sent between non-adjacent nodes) for which bandwidth management is significantly easier. No nontrivial upper bound is known in the standard CONGEST model. As far as lower bounds are concerned, the locality of triangle finding rules out many standard approaches used to obtain lower bounds on the complexity of global problems (e.g., the approaches from [35, 13]). The only known lower bounds have been obtained recently by Drucker et al. [9], but hold only for the much weaker broadcast CONGEST model, where at each round the nodes can broadcast only a single common message to all other nodes, under a (reasonable) conjecture in communication complexity theory. No nontrivial lower bound is known for triangle finding in the standard CONGEST model.

Another, more practical, motivation for considering triangle finding is that for several graph problems faster algorithms are known over triangle-free graphs (we refer to [18, 33] for some examples in the distributed setting). The ability to efficiently check if the network is triangle-free, and more generally detect which part of the network is triangle-free, is essential when considering such algorithms in practice.

Technical contribution.

In this paper, in addition to triangle finding we also consider the triangle listing problem, which requires that each triangle of the network should be output by at least one node (we refer to Section 2 for the formal definition). The triangle listing problem can be seen as a special case of motif finding, which is a popular problem in the context of network data analysis. It is obvious that triangle finding is not harder than triangle listing, since finding reduces to listing. In the literature mentioned above, triangle finding and triangle listing are not explicitly distinguished, but the algorithms by Dolev et al. [8] are actually for the listing version, while the algorithms by Censor-Hillel et al. [6] are based on an algebraic approach and only support finding. The lower bound by Drucker et al. [9] applies to triangle finding.

Our results are summarized in Table 1. Our main contributions are a $O(n^{2/3}(\log n)^{2/3})$-round algorithm for triangle finding and a $O(n^{3/4}\log n)$-round algorithm for triangle listing, both in the CONGEST model. These two algorithms are the first algorithms with sublinear round complexity for triangle finding or listing applicable to the standard CONGEST model. The existence of sublinear-time algorithms shows, from an algorithmic perspective as well, that these two problems are indeed easier than global problems like diameter computation, which has a nearly linear-time lower bound in the CONGEST model [13]. Interestingly, this result contrasts with the known relations between triangle finding and diameter computation in the centralized setting, in which the best known algorithms for both problems rely on matrix multiplication and have the same complexity.

We also show that there exist networks of $n$ nodes for which any triangle listing algorithm requires $\Omega(n^{1/3}/\log n)$ rounds in the CONGEST model. Actually we show a stronger result: any triangle listing algorithm requires $\Omega(n^{1/3}/\log n)$ rounds even in the CONGEST clique model. This lower bound slightly improves the $\Omega(n^{1/3}/\log^{3}n)$-round lower bound for triangle listing in the CONGEST clique model obtained recently by Pandurangan et al. [29]. Note that since the algorithm by Dolev et al. [8] has round complexity $O(n^{1/3}(\log n)^{2/3})$, these lower bounds are tight up to possible polylogarithmic factors in the CONGEST clique model. These lower bounds also have the following interesting consequence. They shows that triangle listing is strictly harder than triangle finding in the CONGEST clique model since, as already mentioned, $(n^{0.1572})$-round algorithms for triangle finding have been shown by Censor-Hillel et al. [6]. Actually, since the algorithms in [6] also count the number of triangles, these lower bounds thus even show that triangle listing is harder than counting in this model.

Our lower bound is shown by a simple information-theoretic argument on random graphs. By similar arguments (see Proposition 5 in Section 4), we can also show a $\Omega(n/\log n)$-round lower bound for local listing algorithms, where each node $i$ is required to output all the triangles containing $i$. This corollary implies that any triangle listing algorithm with sublinear complexity inherently requires some counter-intuitive mechanism that enables a triangle $t$ to be output by a node not contained in $t$. This is precisely how our $O(n^{3/4}\log n)$-round algorithm works.

Other related works.

Distributed algorithms for triangle-freeness have recently also been considered in the setting of property testing [5] (see also [12]). Note that in property testing the goal is to decide whether either the network is triangle-free or it contains a large number triangles. Since there is no need to consider the case where the network may have only a small number of triangles, this property testing version is significantly easier than the problems studied in the present paper.

Triangle finding is a fundamental problem in the field of centralized algorithms as well. It has been known for a long time that this problem is not harder than Boolean matrix multiplication [20]. A few years ago Vassilevska Williams and Williams showed a converse reduction [36]: they proved that a subcubic-time algorithm for triangle finding can be used, in a combinatorial way, to construct a subcubic-time algorithm for Boolean matrix multiplication. This result, combined with recent developments [2, 7, 30, 37], have put triangle finding as a central problem in the recent theory of fine-grained complexity.

2 Preliminaries

In this paper we consider undirected graphs. We will use $G=(V,E)$ to denote the graph considered, and write $n=|V|$ and $m=|E|$. In this section we present some of our notations, give details of our model and present some facts about hashing functions that will be used in Section 3.

Graph-theoretic notations.

For any vertex $i\in V$, we denote $\mathcal{N}(i)$ the set of neighbors of $i$. For any finite set $X$, we will use the notation $\mathcal{E}(X)$ to represent the set of unordered pairs of elements in $X$, and use $\mathcal{T}(X)$ to represent the set of unordered triples of elements in $X$. We will write $\mathcal{E}=\mathcal{E}(V)$ and $\mathcal{T}=\mathcal{T}(V)$. Given a pair of vertices $\{j,k\}\in\mathcal{E}$, we write

[TABLE]

Given $t=\{j,k,l\}\in\mathcal{T}$, and $e\in\mathcal{E}$, we will write $e\in t$ when $e=\{j,k\}$, $e=\{j,l\}$, or $e=\{k,l\}$. For any $R\subseteq\mathcal{T}$, we denote by $\mathcal{P}(R)\subseteq E$ the set of edges $e\in E$ such that $e\in t$ for some triple $t\in R$.

We define a triangle $t=\{j,k,l\}\in\mathcal{T}$ to be an unordered triple of vertices where any pair corresponds to an edge in $E$. Note that if $e$ is an edge of the graph, then $\#(e)$ represents the number of triangles containing $e$. We write $T(G)$ the set of all triangles contained in graph $G$.

Communication Model.

In the paper we mainly consider the CONGEST communication model. The graph $G=(V,E)$ represents the topology of the network, executions proceed with round-based synchrony and each node can transfer one $O(\log n)$-bit message to each adjacent node per round. All links and nodes (corresponding to the edges and vertices of $G$, respectively) are reliable and suffers no faults. Each node has a distinct identifier from a domain $\mathcal{I}$. For simplicity we will assume $\mathcal{I}=V=[0,n-1]$, but this assumption is not essential and easy to remove as long as $|\mathcal{I}|=\mathrm{poly}(n)$. It is also assumed that each node can access infinite sequence of local random bits, that is, the algorithm can be randomized. Initially, each node knows nothing about the topology of the network except the set of edges incident to itself and the value of $n$. All our upper bounds given in Section 3 hold for the CONGEST model.

The CONGEST clique model is a powerful variant of the CONGEST model. It allows an algorithm to transfer a $O(\log n)$-bit message per round between any two nodes not necessarily adjacent in $G$ at each round. This means that in this model the communication topology is the complete graph on the $n$ nodes, and the graph $G$ only takes the role of input instances to the algorithm. Except for the communication topology, all other features are common with the CONGEST model described in the above paragraph. The CONGEST clique model will be considered only in Section 4 when proving our lower bound (note that a lower bound for this model immediately holds for the CONGEST model as well).

Triangle finding and listing in the CONGEST model.

In the triangle finding problem, at least one node must output a triangle if $T(G)$ is not empty, or all the nodes must output “not found” otherwise. In the triangle listing problem, the goal is that for each triangle in $T(G)$ at least one node in $V$ outputs it.

Formally, we describe the output of an algorithm for triangle finding or listing by an $n$-tuple $T=(T_{0},T_{1},\dots,T_{n-1})$, where $T_{i}\subseteq T(G)$ is the output by node $i$. The algorithm can be deterministic or randomized. In the latter case, note that the condition on the $T_{i}$’s implies that any triple output at a node should corresponds to a triangle of $G$, and thus the algorithm should be one-sided error. Note also that we do not require that the $T_{i}$’s are mutually disjoint. We often use notation $T$ as the union of $T_{i}$ over all nodes if there is no ambiguity. We say that the algorithm solves the triangle finding problem if its output $T$ satisfies $T\cap T(G)\neq\emptyset$. We say that it solves the triangle listing problem if $T=T(G)$.

Hash functions.

Let $\mathcal{X}$ and $\mathcal{Y}$ be two finite sets. For any integer $s\geq 1$, a family of hash functions $\mathcal{H}=\{h_{1},h_{2},\dots,h_{p}\}$, where each $h_{i}$ is a function from $\mathcal{X}$ to $\mathcal{Y}$, is called s-wise independent if for any distinct $x_{1},x_{2},\dots,x_{s}\in\mathcal{X}$ and any $y_{1},y_{2},\dots y_{s}\in\mathcal{Y}$, a function $h$ sampled from $\mathcal{H}$ uniformly at random satisfies $\Pr[\bigwedge_{1\leq i\leq s}h(x_{i})=y_{i}]=1/|\mathcal{Y}|^{s}$. We will use the following lemma, which follows almost immediately from the definition of $s$-wise independence.

Lemma 1**.**

Let $\mathcal{H}$ be any $3$-wise independent family of hash functions from $\mathcal{X}$ to $\mathcal{Y}$, and $h$ be a function sampled from $\mathcal{H}$ uniformly at random. Let $H(y)=\{x^{\prime\prime}\in\mathcal{X}\>|\>h(x^{\prime\prime})=y\}$. For any triple $(x,x^{\prime},y)\in\mathcal{X}\times\mathcal{X}\times\mathcal{Y}$ we have

[TABLE]

Proof.

Let us write $Z=\{x^{\prime\prime}\in\mathcal{X}\>|\>h(x^{\prime\prime})=y\}$. For any $a\in\mathcal{X}$, let $Z_{a}$ be the indicator random variable corresponding to the event $a\in Z$. By the 3-wise independence property of $h$, we have

[TABLE]

By Markov’s inequality, we have

[TABLE]

Since $\Pr[Z_{x}=Z_{x^{\prime}}=1]=1/|\mathcal{Y}|^{2}$ holds, we obtain

[TABLE]

as claimed. ∎

Note that using the standard construction by Wegman and Carter [38] we can encode $k$-wise independent hash functions using only $O(k\log|\mathcal{Y}|)$ bits.

3 Upper Bounds

In this section we prove the following two theorems.

Theorem 1**.**

Let $\delta>0$ be any constant. In the CONGEST model there exists a randomized algorithm for triangle finding with round complexity $O(n^{2/3}(\log n)^{2/3})$, where $n$ denotes the size of the network, and success probability at least $1-\delta$.

Theorem 2**.**

In the CONGEST model there exists a randomized algorithm for triangle listing with round complexity $O(n^{3/4}\log n)$ and success probability at least $1-1/n$, where $n$ denotes the size of the network.

Theorems 1 and 2 follow from three algorithms described in Propositions 1–3 below, which rely on the following concept of heavy triangles. Let $\varepsilon$ be any real number such that $0\leq\varepsilon\leq 1$. We say that a triangle $t\in T(G)$ is $\varepsilon$-heavy if there exists an edge $e\in t$ such that $\#(e)\geq n^{\varepsilon}$. We define ${T}_{\varepsilon}(G)\subseteq T(G)$ as the set of all $\varepsilon$-heavy triangles in $T(G)$. The first proposition is almost trivial, and shows how to find an $\varepsilon$-heavy triangle by a straightforward sampling strategy:

Proposition 1**.**

There exists a $O(n^{1-\varepsilon})$-round randomized algorithm $\mathcal{A}_{1}$ returning a set $T\subseteq T(G)$ such that, if ${T}_{\varepsilon}(G)\neq\emptyset$, then $T\cap{T}_{\varepsilon}(G)\ \neq\emptyset$ with probability $\Omega(1)$.

Proof.

Algorithm $\mathcal{A}_{1}$ is as follows: First, each node $j\in V$ constructs a random set $S_{j}\subseteq\mathcal{N}(j)$ by including in $S_{j}$ each element of $\mathcal{N}(j)$ with probability $n^{-\varepsilon}$. If $|S_{j}|>4n^{1-\varepsilon}$, node $j$ then does not send anything to its neighbors. Otherwise (i.e., if $|S_{j}|\leq 4n^{1-\varepsilon}$), node $j$ then sends $S_{j}$ to each neighbor $k\in\mathcal{N}(j)$, and each such neighbor $k$ checks if there is a triangle containing $j$, $k$ and a third node in $S_{j}$, which can be done by computing locally the set $\mathcal{N}(k)\cap S_{j}$.

Observe that if ${T}_{\varepsilon}(G)\neq\emptyset$ then at least one $\varepsilon$-heavy triangle will be found with constant probability. Indeed, for each edge $\{j,k\}\in E$ such that $\#(\{j,k\})\geq n^{\varepsilon}$, with constant probability at least one node adjacent to both $j$ and $k$ is included in $S_{j}$, and $S_{j}$ is small enough. ∎

The second proposition is about finding each $\varepsilon$-heavy triangle:

Proposition 2**.**

There exists a $O(n^{1-\varepsilon/2})$-round randomized algorithm $\mathcal{A}_{2}$ returning a set $T\subseteq T(G)$ such that, for any triangle $t\in{T}_{\varepsilon}(G)$, this set $T$ contains $t$ with probability $\Omega(1)$.

The third proposition is about finding each triangle that is not $\varepsilon$-heavy:

Proposition 3**.**

There exists a $O(n^{1-\varepsilon}+n^{(1+\varepsilon)/2}\log n)$-round randomized algorithm $\mathcal{A}_{3}$ returning a set $T\subseteq T(G)$ such that, for any triangle $t\in T(G)\setminus{T}_{\varepsilon}(G)$, this set $T$ contains $t$ with probability $\Omega(1)$.

Proposition 2 and especially Proposition 3 are the main technical contributions of this section. Their proofs are given in Subsections 3.1 and 3.2, respectively.

We now explain how Theorems 1 and 2 immediately follow from these three propositions.

Proof of Theorem 1.

The triangle finding algorithm simply applies Algorithm $\mathcal{A}_{1}$ and then Algorithm $\mathcal{A}_{3}$. From Propositions 1 and 3 we know that a triangle will thus be found with at least constant probability (if $G$ contains a triangle). For any constant $\delta$ the success probability can be amplified to $1-\delta$ by repeating this process $c$ times for a large enough constant $c$.

The round complexity of this algorithm is $O(n^{1-\varepsilon}+n^{1-\varepsilon}+\allowbreak n^{(1+\varepsilon)/2}\log n).$ Choosing $\varepsilon$ such that $n^{\varepsilon}=\frac{n^{1/3}}{(\log n)^{2/3}}$ gives the claimed upper bound. ∎

Proof of Theorem 2.

The triangle listing algorithm repeats $\left\lceil c\log n\right\rceil$ times the following process (here $c$ is a large constant): apply Algorithm $\mathcal{A}_{2}$ and then Algorithm $\mathcal{A}_{3}$.

We now show that this algorithm lists all the triangles of $G$. Let $t$ be a triangle in $T(G)$. From Propositions 2 and 3 we know that $t$ is found with at least constant probability at each step. If $c$ is large enough, repeating this process $\left\lceil c\log n\right\rceil$ times guarantees that $t$ is found with probability at least $1-1/n^{4}$. From the union bound, we can conclude that all triangles are found with probability at least $1-1/n$.

The round complexity of this algorithm is $O(((n^{1-\varepsilon/2}+n^{1-\varepsilon}\allowbreak+n^{(1+\varepsilon)/2}\log n)\log n).$ Choosing $\varepsilon$ such that $n^{\varepsilon}=\frac{n^{1/2}}{(\log n)^{2}}$ gives the claimed upper bound. ∎

3.1 Listing all $\varepsilon$-heavy triangles: Proof of Proposition 2

The goal of this subsection is to prove Proposition 2.

The main idea to find $\varepsilon$-heavy triangles is that each node $j$ will decide which information about $\mathcal{N}(j)$ it will send to each neighbor $a$ according to a hash function $h_{a}$ generated by $a$. More precisely, the function $h_{a}$ will be taken (by node $a$, and then distributed to all its neighbors) from a 3-wise independent family $\mathcal{H}$ of hash functions from $V$ to $\{0,1,\ldots,\lfloor n^{\varepsilon/2}\rfloor-1\}$, and $j$ will send an edge $\{j,l\}$ to $a$ if $h_{a}(l)=0$. The complete algorithm, which is Algorithm $\mathcal{A}_{2}$ claimed in Proposition 2, is described in Figure 1 and analyzed below.

We first prove the correctness of Algorithm $\mathcal{A}_{2}$. Let $t=\{j,k,l\}$ be any $\varepsilon$-heavy triangle of $G$. Let $\{j,k\}$ be the edge shared by at least $n^{\varepsilon}$ triangles and $A$ be the set of nodes such that $\{j,k,a\}$ forms a triangle for each $a\in A$. Consider the function $h_{a}\in\mathcal{H}$ chosen by node $a$. Applying Lemma 1 with $|\mathcal{X}|=n$ and $|\mathcal{Y}|=\lfloor n^{\varepsilon/2}\rfloor$, we obtain the inequality

[TABLE]

This bound implies that with probability at least $\frac{3}{4n^{\varepsilon}}$ node $a$ receives $\{j,k\}$ from $j$, $\{j,l\}$ from $j$ and $\{k,l\}$ from $k$ at Step 2, and thus $T_{a}$ (i.e., the output of node $a$) includes $t$ with the same probability. Since the events $t\not\in T_{a}$ are mutually independent over all $a\in A$, we can bound the probability that no node in $A$ finds $t$ as follows:

[TABLE]

The round complexity of Algorithm $\mathcal{A}_{2}$ is $O(n^{1-\varepsilon/2})$ since the hash function $h_{i}$ sent at Step 1 can be encoded using $O(\log n)$ bits, as explained in Section 2.

This concludes the analysis of Algorithm $\mathcal{A}_{2}$ and the proof of Proposition 2.

3.2 Finding triangles that are not heavy: Proof of Proposition 3

The goal of this subsection is to prove Proposition 3. We first give a brief description of the main ideas underlying our algorithm before giving the full description of Algorithm $\mathcal{A}_{3}$.

Key definition and outline of our approach.

For any set $X\subseteq V$, define the set

[TABLE]

which is the set of pairs of nodes that do not have a common neighbor in $X$. The following easy lemma shows how the set $\Delta(X)$ is related to finding triangles which are not $\varepsilon$-heavy.

Lemma 2**.**

Let $\varepsilon$ be any real number such that $0\leq\varepsilon\leq 1$. Suppose that $X$ is a set obtained by including each node of $V$ into $X$ with probability $\frac{1}{9n^{\varepsilon}}$. Then, for any triangle $t\in T(G)\setminus{T}_{\varepsilon}(G)$, the three edges of $t$ are in $\Delta(X)$ with probability at least $2/3$.

Proof.

Let us consider any triangle $t\in T(G)\setminus{T}_{\varepsilon}(G)$. For each edge $e\in t$ we have $\#(e)<n^{\varepsilon}$. From the union bound, we obtain the inequality $\Pr_{X}\left[e\in\bigcup_{x\in X}\mathcal{E}(\mathcal{N}(x))\right]<\frac{1}{9}.$ Thus, again from the union bound, $t$ has its three edges in $\Delta(X)$ with probability at least $2/3$. ∎

In view of Lemma 2, our strategy will be to take a set $X$ as in the lemma and then find the triangles with three edges in $\Delta(X)$ using the following approach: Each node $i\in V$ sends to all its neighbors the set $\mathcal{N}(i)\cap X$, in $O(|X|)$ rounds. Then each node $k\in V$ constructs for each $j\in\mathcal{N}(k)$ the set containing all nodes $l\in\mathcal{N}(k)$ such that $\{j,l\}\in\Delta(X)$, which can be done locally. Let us call this set $\mathcal{S}(j,k)$ for now – later it will be called $\mathcal{S}_{V}^{X}(j,k)$. Node $k$ then sends $\mathcal{S}(j,k)$ to neighbor $j$, who can report all triangles of the form $\{j,k,l\}$ with $\{j,l\}\in\Delta(X)$.

This approach works, but its round complexity depends on the size of the sets $\mathcal{S}(j,k)$. The crucial point is that we can show from a combinatorial argument that with high probability (on the choice of $X$) the average size of these sets is small. The main remaining issue is that, even if the average size is small, in general there exist pairs $(j,k)$ for which $\mathcal{S}(j,k)$ is large. We solve this issue by sending $\mathcal{S}(j,k)$ only when its size is close to the average and using a different strategy when its size exceeds the average. This latter strategy is based on a notion of “good” nodes. Roughly speaking, a node $j$ is good if it has only a small number of neighbors $k$ such that $\mathcal{S}(j,k)$ is large (see Definition 1 for the formal definition). The same combinatorial argument as above guarantees that most nodes are good (this is shown in Lemma 3 below). Triangles containing at least one good node are fairly easy to deal with, and we can deal with triangle containing three bad nodes by applying the same approach recursively on the subgraph induced by the bad nodes. Our final algorithm will thus be recursive: it will keep a set $U\subseteq V$, with initially $U=V$, and successively search for triangles in the subgraph of $G$ induced by $U$, removing the good nodes from $U$ at each step, until $U=\emptyset$.

Further definitions and full description of Algorithm $\mathcal{A}_{3}$.

For any set $U\subseteq V$ and any nodes $j,k\in U$ such that $\{j,k\}\in E$, we define the set $\mathcal{S}_{U}^{X}(j,k)\subseteq U$ as follows:

[TABLE]

Note that this definition is asymmetric: we have $\mathcal{S}_{U}^{X}(j,k)\neq\mathcal{S}_{U}^{X}(k,j)$ in general. Let $r$ be any positive real number. For any node $j\in U$, we define the set

[TABLE]

Finally, we will use the following concept of good nodes.

Definition 1**.**

Let $U$ and $X$ be any subsets of $V$, and $r$ be any positive real number. A node $j\in U$ is $r$-good for $(U,X)$ if \big{|}\mathcal{V}_{U,r}^{X}(j)\big{|}\leq r.

The following crucial lemma shows an upper bound on the number of nodes which are not good, when $X$ is chosen as in Lemma 2.

Lemma 3**.**

Let $\varepsilon$ be any real number such that $0\leq\varepsilon\leq 1$ and $X$ be a set chosen at random as in Lemma 2. Then, for any real number $r\geq\sqrt{54n^{1+\varepsilon}\log n}$, the following statement holds with probability at least $1-1/n$:

[TABLE]

Proof.

Consider any pair $\{j,l\}\in\mathcal{E}$ such that

[TABLE]

We have

[TABLE]

From the union bound we can thus conclude that with probability at least $1-1/n$ the following statement holds:

[TABLE]

We now show that Statement (2) implies Statement (1). Let us consider the number of ordered triples $(j,k,l)\in U\times U\times U$ such that $\{j,l\}\in\Delta(X)$, $\{j,k\}\in E$ and $\{k,l\}\in E$. If Statement (2) holds then this number is at most $27|U|^{2}n^{\varepsilon}\log n$. This number of triples can also be computed in another way: it is equal to

[TABLE]

Thus if Statement (2) holds we obtain the inequality

[TABLE]

which implies that the number of nodes that are not $r$-good for $(U,X)$ is at most

[TABLE]

For any $r\geq\sqrt{54n^{1+\varepsilon}\log n}$ we obtain the claimed upper bound. ∎

We now present an algorithm that lists all triangles of $G$ with three edges in $\Delta(X)$. The algorithm is denoted $\mathcal{A}(X,r)$ and described in Figure 2. We analyze it in the next proposition.

Proposition 4**.**

Assume that the set $X$ satisfies Statement (1). Then Algorithm $\mathcal{A}(X,r)$ terminates after $O(\log n)$ iterations of the while loop, has overall round complexity $O(|X|+r\log n)$, and its output $T\subseteq T(G)$ includes all the triangles of $G$ with three edges in $\Delta(X)$.

Proof.

Let us first show that Algorithm $\mathcal{A}(X,r)$ terminates after $O(\log n)$ iterations of the while loop. The assumption on the set $X$ implies that $|U\setminus U^{\prime}|\leq|U|/2$ at Step 4.2 of each iteration of the while loop. Since we start with $|U|=n$, after at most $\log_{2}(n)+1$ iterations of the while loop the set $U$ becomes empty, at which point we exit the while loop.

We now analyze the overall round complexity of the algorithm by considering the complexity of each step. Step 1 requires only one round. Note that after Step 1 each node $k$ can locally compute the set $\mathcal{N}(k)\cap X$. Step 2 can then be implemented using at most $|X|$ rounds, since $|\mathcal{N}(k)\cap X|\leq|X|$. Step 4.1 can be implemented using at most $r$ rounds. Step 4.2 does not require any communication since the enough information has been obtained at Step 4.1 to compute $\mathcal{V}_{U,r}^{X}(k)$ locally. Step 4.3 only requires at most $r$ rounds, since $|\mathcal{V}_{U,r}^{X}(j)|\leq r$ for any $j\in U^{\prime}$. Finally, Step 4.5 obviously requires only one round. The overall round complexity is thus at most

[TABLE]

We finally show that the algorithm lists all triangles of $G$ with three edges in $\Delta(X)$. First observe that for any set $U\subseteq V$, any triangle of $G$ with three nodes in $U$ and three edges in $\Delta(X)$ satisfies at least one of the following three properties (where $U^{\prime}\subseteq U$ denotes the set of nodes that are $r$-good for $(U,X)$):

• (a)

it contains three distinct nodes $j,k,l\in U$ such that $\left|\mathcal{S}_{U}^{X}(j,k)\right|\leq r$ and $l\in\mathcal{S}_{U}^{X}(j,k)$;

• (b)

it contains two distinct nodes $j,k\in U$ such that $j\in U^{\prime}$ and $k\in\mathcal{V}_{U,r}^{X}(j)$;

• (c)

all its three nodes are in $U\setminus U^{\prime}$.

Indeed, if such a triangle does not satisfy Property (a) then the inequality $|\mathcal{S}_{U}^{X}(j,k)|>r$ holds for any two nodes $j$ and $k$ of the triangle (which means that $k\in\mathcal{V}_{U,r}^{X}(j)$). In that case it should satisfy either Property (b) or Property (c).

Algorithm $\mathcal{A}(X,r)$ starts with $U=V$ and decreases the set $U$ until it is empty. Let us consider what happens at each execution of the while loop, with the current set $U$. All triangles of type (a) are found at Step 4.1 and all triangles of type (b) are found at Step 4.3. The only remaining triangles are triangles of type (c). They are considered at the next execution of the while loop, where $U$ is replaced by $U\setminus U^{\prime}$. ∎

We are now ready to present Algorithm $\mathcal{A}_{3}$ and give the proof of Proposition 3.

Proof of Proposition 3.

Algorithm $\mathcal{A}_{3}$ is as follows. First each node selects itself with probability $\frac{1}{9n^{\varepsilon}}$. Then the nodes run Algorithm $\mathcal{A}(X,r)$ with $X$ being the set of selected nodes (note that each node $i$ of the network knows whether $i\in X$ or not, as required) and $r=\sqrt{54n^{1+\varepsilon}\log n}$, but stop as soon as the round complexity exceeds $c\times(n^{1-\varepsilon}+n^{(1+\varepsilon)/2}\log n)$ for some large enough constant $c$.

By construction, the round complexity of Algorithm $\mathcal{A}_{3}$ is

[TABLE]

Let $t$ be any triangle in $T(G)\setminus{T}_{\varepsilon}(G)$, and let us show that Algorithm $\mathcal{A}_{3}$ finds $t$ with constant probability. Note that the expectation of the value $|X|$ is $\frac{1}{9}n^{1-\varepsilon}$. By Chernoff bound, we know that the probability that $|X|>\frac{2}{9}n^{1-\varepsilon}$ is negligible. Combining this observation with Lemmas 2 and 3, we conclude (using the union bound) that with probability $\Omega(1)$ the following three conditions hold: $X$ has size at most $\frac{2}{9}n^{1-\varepsilon}$, $X$ satisfies Statement (1), and $t$ has its three edges in $\Delta(X)$. From Proposition 4 we know that in this case algorithm $\mathcal{A}(X,r)$ stops within $O(n^{1-\varepsilon}+n^{(1+\varepsilon)/2}\log n)$ rounds and finds $t$. By choosing the constant $c$ large enough we can thus guarantee that the output of Algorithm $\mathcal{A}_{3}$ contains the triangle $t$ with probability $\Omega(1)$. ∎

4 Lower Bounds

This section proves the following lower-bound theorem.

Theorem 3**.**

Let $\mathcal{A}$ be any triangle listing algorithm with error probability less than $1/32$. Then there exists a probability distribution on inputs such that the expected round complexity of $\mathcal{A}$ is $\Omega(n^{1/3}/\log n)$.

In this section we will write $V=\{0,1,\ldots,n-1\}$. Without loss of generality, the run of any algorithm $\mathcal{A}$ for triangle listing on any given instance $G=(V,E)$ can be described by two following steps:

Each node $i$ locally constructs its initial state $\boldsymbol{\rho}_{i}$ according to $G$. This state depends on the set of edges incident to $i$, but is independent of all other edges. 2. 2.

Each node $i$ construct its output $\boldsymbol{T}_{i}$ from $\boldsymbol{\rho}_{i}$ and the transcript $\boldsymbol{\pi}_{i}$ of the communication received it receives during the execution of the algorithm.

To prove Theorem 3, we consider as input the random graph $G(n,1/2)$, which is the graph on $n$ nodes where each pair of nodes is independently taken as an edge with probability $1/2$. Since $\boldsymbol{\rho}_{i}$, $\boldsymbol{\pi}_{i}$, and $\boldsymbol{T}_{i}$ depend only on the algorithm $\mathcal{A}$ (and its random bits if $\mathcal{A}$ is randomized) and the input $G$, we see all of them as random variables. For any pair $\{j,k\}\in\mathcal{E}$, let $\boldsymbol{e}_{\{j,k\}}$ be the random variable with value 1 if $\{j,k\}$ is an edge, and value 0 otherwise. Let $\boldsymbol{E}=(\boldsymbol{e}_{\{0,1\}},\boldsymbol{e}_{\{0,2\}},\dots,\boldsymbol{e}_{\{n-2,n-1\}})$ be the concatenation of these $|\mathcal{E}|$ random variables. The proof idea is to bound the amount of information in $\boldsymbol{\pi}_{i}$ necessary to construct $\boldsymbol{T}_{i}$ locally. We write $\boldsymbol{T}=(\boldsymbol{T}_{0},\boldsymbol{T}_{1},\ldots,\boldsymbol{T}_{n-1})$ and use the notation $w(\boldsymbol{T})$ to represent the node identifier $i$ such that $|T_{i}|$ is maximum (i.e., the index of the node that outputs the maximum number of triangles).

Our proof relies on the following graph-theoretic lemma, which is shown in [34].

Lemma 4**.**

If a graph $G$ contains $t$ triangles, then $G$ has at least $\frac{\sqrt{2}}{3}t^{2/3}$ edges.

We first recall the definition of the entropy. For a random variable $\boldsymbol{X}$ with domain $\mathcal{X}$ and probability distribution $p$, its entropy $H(\boldsymbol{X})$ is defined as $H(\boldsymbol{X})=-\sum_{x\in\mathcal{X}}p(x)\log p(x)$. The conditional entropy can be defined similarly. For any random variables $\boldsymbol{X}$ and $\boldsymbol{Y}$ the mutual information of $\boldsymbol{X}$ and $\boldsymbol{Y}$ is defined as $I(\boldsymbol{X};\boldsymbol{Y})=H(\boldsymbol{X})-H(\boldsymbol{X}|\boldsymbol{Y})$. We will use in our proofs the following standard results from information theory about the mutual information.

Fact 1**.**

For any random variables $\boldsymbol{X}$, $\boldsymbol{Y}$, and $\boldsymbol{Z}$, the following three properties hold:

• •

$I(\boldsymbol{X};\boldsymbol{Y})=I(\boldsymbol{Y};\boldsymbol{X})$,

• •

$I(\boldsymbol{X};\boldsymbol{Y})\leq H(\boldsymbol{X})$* (and $I(\boldsymbol{X};\boldsymbol{Y})\leq H(\boldsymbol{Y})$), and*

• •

$I(\boldsymbol{X};\boldsymbol{Y})\geq I(\boldsymbol{X};(\boldsymbol{Y},\boldsymbol{Z}))-I(\boldsymbol{X};\boldsymbol{Z})$.

Fact 2** (Data Processing Inequality).**

For any three random variables $\boldsymbol{X},\boldsymbol{Y},\boldsymbol{Z}$ such that $\boldsymbol{X}$ and $\boldsymbol{Z}$ are conditionally independent given $\boldsymbol{Y}$, $I(\boldsymbol{X};\boldsymbol{Y})\geq I(\boldsymbol{X};\boldsymbol{Z})$.

The key technical ingredient of our proof is the following lemma (the notation $\mathcal{P}$ is defined in Section 2).

Lemma 5**.**

For any node $i$, the inequality $I(\boldsymbol{E};\boldsymbol{T}_{i})\geq E[|\mathcal{P}(\boldsymbol{T}_{i})|]$ holds.

The proof of Lemma 5 is based on an information-theoretic argument. The intuition is very simple: since the information $\boldsymbol{T}_{i}$ completely reveals the information on the edges forming triangles in $\boldsymbol{T}_{i}$, it must contain all the information on $\mathcal{P}(\boldsymbol{T}_{i})$.

We will write $M=|\mathcal{E}|=\frac{n(n-1)}{2}$ and $N=|\mathcal{T}|=\frac{n(n-1)(n-2)}{6}$.

Proof of Lemma 5.

Since the random variables $\boldsymbol{e}_{\{j,k\}}$ are independent of each other, we have

[TABLE]

where the last equality comes from the assumption that Algorithm $\mathcal{A}$ never outputs a triple that is not a triangle (thus $\Pr[\boldsymbol{T}_{i}=R]\neq 0$ only if $R\subseteq T(G)$, and conditioned to this event we have $\boldsymbol{e}_{\{j,k\}}=1$ with probability $1$ for any $\{j,k\}\in\mathcal{P}(R)$). Since $H(\boldsymbol{e}_{\{j,k\}}|\boldsymbol{T}_{i}=R)\leq 1$ always holds, we conclude that

[TABLE]

as claimed. ∎

Theorem 3 is proved by combining Lemma 4 and Lemma 5. The intuition is again fairly simple: In expectation, an instance of $G(n,1/2)$ contains $\Omega(n^{3})$ triangles, and thus the average number of triangles output per node node is $\Omega(n^{2})$. Thus node $w(\boldsymbol{T})$ outputs at least $\Omega(n^{2})$ triangles and, from Lemma 4, we obtain $E[|\mathcal{P}(\boldsymbol{T}_{w(\boldsymbol{T})})|]=\Omega(n^{4/3})$. Lemma 5 then gives the same lower bound for the mutual information between $\boldsymbol{E}$ and $\boldsymbol{T}_{w(\boldsymbol{T})}$, which then gives the lower bound $\Omega(n^{4/3})$ on the amount of communication received by node $w(\boldsymbol{T})$ during the execution of Algorithm $\mathcal{A}$. This implies the claimed $\Omega(n^{1/3}/\log n)$-round lower bound for triangle listing since $w(\boldsymbol{T})$ can receive at most $O(n\log n)$ bits of information per round.

Proof of Theorem 3.

From Lemma 5, we have

[TABLE]

By Lemma 4, for any $R\subseteq T(G)$ the inequality $|\mathcal{P}(R)|\geq\frac{\sqrt{2}}{3}|R|^{2/3}$ holds. We thus have

[TABLE]

The expected number of triangles in $G(n,1/2)$ is $N/8$ and thus, since there cannot be more than $N$ triangles, with probability at least $1/15$ the number of triangles exceeds $N/16$. We conclude that the inequality $|\boldsymbol{T}_{w(\boldsymbol{T})}|\geq N/(16n)$ necessarily holds if the number of triangles is at least $N/16$ and Algorithm $\mathcal{A}$ correctly lists all the triangles of the graph, which occurs with overall probability probability at least $1/15-1/32$. Consequently we obtain

[TABLE]

From Fact 1 we have

[TABLE]

Since the initial knowledge of each node $i$ is only the set of edges incident to itself, the inequality

[TABLE]

holds for each node $i\in V$. Since the output $\boldsymbol{T}_{w(\boldsymbol{T})}$ is computed locally only from the transcript $\boldsymbol{\pi}_{w(\boldsymbol{T})}$ and the initial state $\boldsymbol{\rho}_{w(\boldsymbol{T})}$, the random variables $\boldsymbol{E}$ and $\boldsymbol{T}_{w(\boldsymbol{T})}$ are conditionally independent given $(\boldsymbol{\rho}_{w(\boldsymbol{T})},\boldsymbol{\pi}_{w(\boldsymbol{T})})$. We can thus use Fact 2 in Inequality (4), which combined with Inequalities (3) and (5) gives

[TABLE]

Since $H(\boldsymbol{\pi}_{i})$ lower bounds the average length of the transcript $\boldsymbol{\pi}_{i}$, this implies that node ${w(\boldsymbol{T})}$ receives messages of average total length $\Omega(n^{4/3})$ bits. Since node ${w(\boldsymbol{T})}$ can receive only $O(n\log n)$ bits per round, we conclude that the expected round complexity of Algorithm $\mathcal{A}$ is $\Omega(n^{1/3}/\log n)$. ∎

The information-theoretic arguments of Lemma 5 can also be used to derive the following stronger lower bound mentioned in the introduction for local triangle listing, the setting where each node $i$ is required to output all the triangles containing $i$.

Proposition 5**.**

Let $\mathcal{A}$ be any local triangle listing algorithm with error probability less than $1/32$. Then there exists a probability distribution on inputs such that the expected round complexity of $\mathcal{A}$ is $\Omega(n/\log n)$.

The proof of Proposition 5 is similar to the proof of Theorem 3 but does not even requires Lemma 4: we can immediately obtain the stronger bound $E[|\mathcal{P}(\boldsymbol{T}_{i})|]=\Omega(n^{2})$ since for local triangle listing $\boldsymbol{T}_{i}$ should include all the triangles containing $i$.

Proof of Proposition 5.

The proof is almost similar to the proof of Theorem 3, except that we can derive the stronger lower bound

[TABLE]

instead of the lower bound (3). This new lower bound implies that $H(\boldsymbol{\pi}_{w(\boldsymbol{T})})=\Omega(n^{2})$ and gives the claimed lower bound on the round complexity of the local triangle listing algorithm $\mathcal{A}$.

We now explain how to derive the lower bound (6). From Lemma 5 we get

[TABLE]

since the quantity $|\mathcal{P}(R)|$ is lower bounded by the number of triangles in $R$ containing node $i$. The expected number of triangles in $G(n,1/2)$ containing any fixed node is $M/8$ and thus, since there cannot be more than $M$ such triangles, with probability at least $1/15$ the number of triangles containing node $i$ exceeds $M/16$. Since in Algorithm $\mathcal{A}$ node $i$ correctly lists all the triangles containing $i$ with probability at least $1-1/32$, we conclude that $\boldsymbol{T}_{i}$ includes at least $M/6$ triangles including $i$ with overall probability at least $1/15-1/32$. We thus obtain

[TABLE]

as claimed ∎

Acknowledgments

FLG was partially supported by MEXT KAKENHI (24106009) and JSPS KAKENHI (15H01677, 16H01705, 16H05853). TI was partially supported by JSPS KAKENHI (15H00852, 16H02878) and JST-SICORP Japan-Israel Bilateral Program ”ICT for a resilient society”.