Distributed Detection of Cycles

TL;DR

This paper presents a unified distributed property testing algorithm that detects cycles of any length in constant rounds within the CONGEST model, advancing cycle detection in network graphs.

Contribution

It introduces a general constant-round distributed algorithm for detecting any cycle length $C_k$, extending previous results limited to small cycles.

Findings

Works for all cycle lengths $k \\geq 3$

Operates in constant rounds in the CONGEST model

Has a round complexity of $O(1/\\epsilon)$

Abstract

Distributed property testing in networks has been introduced by Brakerski and Patt-Shamir (2011), with the objective of detecting the presence of large dense sub-networks in a distributed manner. Recently, Censor-Hillel et al. (2016) have shown how to detect 3-cycles in a constant number of rounds by a distributed algorithm. In a follow up work, Fraigniaud et al. (2016) have shown how to detect 4-cycles in a constant number of rounds as well. However, the techniques in these latter works were shown not to generalize to larger cycles $C_k$ with $k\geq 5$. In this paper, we completely settle the problem of cycle detection, by establishing the following result. For every $k\geq 3$, there exists a distributed property testing algorithm for $C_k$-freeness, performing in a constant number of rounds. All these results hold in the classical CONGEST model for distributed network computing. Our algorithm is 1-sided error. Its round-complexity is $O(1/\epsilon)$ where $\epsilon\in(0,1)$ is the property testing parameter measuring the gap between legal and illegal instances.

Figures

Equations

$$O(poly(\text{nicefrac}1ϵ\log (\text{nicefrac}nϵ)))$$

$$\mathrm{Pr}[\text{mbox}everynodeoutputs\text{mbox}\mathsf{accept}]\ge \text{nicefrac}23;$$

$$\mathrm{Pr}[\text{mbox}atleastonenodeoutputs\text{mbox}\mathsf{reject}]\ge \text{nicefrac}23.$$

$$\mathrm{Pr}[\text{mbox}everynodeoutputs\text{mbox}\mathsf{accept}]=1.$$

$$V(H)\subseteq V(G)\text{mbox}andE(H)\subseteq E(G).$$

$$\mathrm{Pr}[\text{mbox}everynodeoutputs\text{mbox}\mathsf{accept}]=1.$$

$$\mathrm{Pr}[\text{mbox}atleastonenodeoutputs\text{mbox}\mathsf{reject}]\ge \text{nicefrac}23.$$

$$r(e^{\prime })>r(e),$$

$$e=\{u,v\},$$

$$|L_1\cup L_2\cup \{\text{mbox}\mathrm{ID}(w)\}|=k,$$

$$L=(y_1,y_2,\dots ,y_{t-1})$$

$$X=\{x_1,x_2,\dots ,x_{k-t}\}$$

$$L^{\prime }=(y_1^{\prime },y_2^{\prime },\dots ,y_{t-1}^{\prime })$$

$$X=\{-1,-2,\dots ,-k+t\}$$

$$|L_1\cup L_2\cup \{\text{mbox}\mathrm{ID}(w)\}|=k.$$

$$L_1=(x_1,x_2,\dots ,x_{\ell }),$$

$$L_2=(y_1,y_2,\dots ,y_m),$$

$$(x_1,x_2,\dots ,x_{\ell },w,y_m,y_{m-1},\dots ,y_1)$$

$$L_1\in \mathcal{S}\text{mbox}and{L}_2\notin \mathcal{S}$$

$$L_1\notin \mathcal{S}\text{mbox}and{L}_2\in \mathcal{S}.$$

$$(x_1,x_2,\dots ,x_{\ell },w,y_m,y_{m-1},\dots ,y_1)$$

$$\mathcal{S}\leftarrow \mathcal{R}$$

$$L=(x_1,x_2,\dots ,x_{t-1})$$

$$x_1,x_2,\dots ,x_{t-1},w,y_1,\dots ,y_{k-t}$$

$$\{X\in \mathcal{X}:X\cap L=\varnothing \}=\varnothing$$

$$\{-1,\dots ,-k+t\}.$$

$$X=\{y_1,\dots ,y_{k-t}\}$$

$$L^{\prime }=(z_1,z_2,\dots ,z_{t-1}).$$

$$z_1,z_2,\dots ,z_{t-1},w,y_1,\dots ,y_{k-t}$$

$$x_1,x_2,\dots ,x_{t-1},w,y_1,\dots ,y_{k-t}$$

Full text

1 Introduction

1.1 Context

1.1.1 Property Testing

The objective of (sequential) property testing [21] is the design of efficient mechanisms for detecting whether data-structures satisfy a given property. In the context of networks, a vast literature has been dedicated to testing the presence or absence of specific patterns like triangles, cycles, cliques, etc. (see, e.g., [2, 3, 11, 22]). A property testing mechanism, a.k.a. tester, is a centralized algorithm ${\mathcal{A}}$ which is given the ability to probe nodes with queries of the form $\mbox{\sf deg}(i)$ returning the degree of the $i$th node, and $\mbox{\sf adj}(i,j)$ returning the identity of the $j$th neighbor of the $i$th node. Beside its running time, the quality of a tester is typically measured by the number of queries that it must perform before deciding whether or not the network satisfies the considered property.

Property testing finds its main interest when the problem is relaxed by simply requiring the tester to distinguish between instances satisfying the property, and instances that are far from satisfying that property. In the context of networks, several notions of farness have been considered. We consider here the so-called sparse model: Given any $\epsilon\in(0,1)$, an $n$-node $m$-edge network $G$ is said to be $\epsilon$-far from satisfying a graph property ${\mathcal{P}}$ if adding and/or removing at most $\epsilon m$ edges to/from $G$ cannot result in a network satisfying ${\mathcal{P}}$.

A tester for a graph property ${\mathcal{P}}$ is a randomized algorithm ${\mathcal{A}}$ that is required to accept or reject any given network instance, under the following two constraints:

• •

$G$ satisfies ${\mathcal{P}}\Longrightarrow\Pr[{\mathcal{A}}\;\mbox{accepts}\;G]\geq\nicefrac{{2}}{{3}}$ ;

• •

$G$ is $\epsilon$-far from satisfying ${\mathcal{P}}\Longrightarrow\Pr[{\mathcal{A}}\;\mbox{rejects}\;G]\geq\nicefrac{{2}}{{3}}$.

The success guarantee $\nicefrac{{2}}{{3}}$ is arbitrary, as one can boost any success guarantee by repetition.

In the case of instances which are nearly satisfying ${\mathcal{P}}$ but not quite, the algorithm can output either ways. Hence, a tester for ${\mathcal{P}}$ is a mechanism enabling to detect degraded instances (i.e., instances that are far from satisfying a desired property ${\mathcal{P}}$) with arbitrarily large probability, while correct instances are accepted also with arbitrarily large probability.

A tester is 1-sided error if

• •

$G$ satisfies ${\mathcal{P}}\Longrightarrow\Pr[{\mathcal{A}}\;\mbox{accepts}\;G]=1$.

1.1.2 Distributed Property Testing

Distributed property testing has been introduced in [6], and recently revisited in [7, 20]. In networks, a distributed tester is a distributed algorithm running at every node in parallel (every node executes the same code). After having inspected its surrounding, i.e., the nodes in its vicinity, every node outputs accept or reject. One says that ${\mathcal{A}}$ accepts a network $G$ if and only if all nodes output accept. That is, ${\mathcal{A}}$ rejects if at least one of the nodes outputs reject.

In this paper, we are focussing on the detection of cycles, one of the most basic and central structures in graph theory, with impact on Ramsey theory and block design. Let $k\geq 3$. A $k$-node cycle, or $k$-cycle for short, is denoted by $C_{k}$. A network $G$ is $C_{k}$-free if and only if $G$ does not contain a $k$-node cycle as a subgraph. A case of particular interest is $k=3$, and a $C_{3}$ is often called triangle.

It has been shown in [7] that, in the classical congest model111The congest model states that all nodes perform synchronously in a sequence of rounds; At each rounds, messages of $O(\log n)$ bits can be exchanged along the edges of the network. for distributed computing [29], there exists a distributed property testing algorithm for triangle-freeness performing in $O(1/\epsilon^{2})$ rounds. This result has been extended in [20] where it is proved that there exists a distributed property testing algorithm for $C_{4}$-freeness performing in $O(1/\epsilon^{2})$ rounds as well.

Perhaps surprisingly, the techniques in [7, 20] do not extend to larger cycles. Indeed, using explicit constructions of so-called Behrend graphs, it was proved in [20] that these techniques fail for most values of $k\geq 5$. That is, these techniques cannot result in a tester performing in a constant number of rounds in all graphs, even if the constant is allowed to be a function of $1/\epsilon$. The existence of distributed property testing algorithms for $C_{k}$-freeness performing in a constant number of rounds was left open for $k$ larger than 4.

1.2 Our results

We completely settle the problem of cycle detection, for every possible length $k\geq 3$. Specifically, we prove that, for every $k\geq 3$, there exists a 1-sided error distributed property testing algorithm for $C_{k}$-freeness, performing in $O(1/\epsilon)$ rounds in the congest model.

Essentially, we reduce the problem of detecting $k$-cycles to the problem of detecting whether a given edge $e$ belongs to some $C_{k}$. At first glance, the latter problem may seem to be much more simple. Indeed, it does not require to deal with the link congestion caused by the simultaneous testing of several edges. However, the problem remains actually quite challenging as, in the congest model, even collecting the identities of the nodes at distance 2 from a given node $u$ might be impossible to achieve in $o(n)$ rounds in $n$-node network. Indeed, $u$ may have constant degree, with $\Omega(n)$ neighbors at distance 2. To overcome this difficulty, we proceed by pruning the set of information transmitted between nodes, namely by pruning the set of candidate cycles passing through the given edge $e$. This pruning is at the risk of discarding candidate cycles that would have turned out to be actual cycles. Nevertheless, our pruning mechanism guarantees that at least one actual cycle remains in the current set of candidate cycles throughout the execution of the algorithm.

Interestingly, the use of randomization is limited to the reduction of the general problem of testing $C_{k}$-freeness to the problem of detecting whether there exists a $k$-cycle passing through a given edge $e$. Indeed, our algorithm solving the latter problem is deterministic. In particular, the aforementioned pruning mechanism is deterministic. That is, the existence of an actual cycle passing through $e$ among the restricted set of candidate cycles kept at each round is not a property that holds under some statistical guarantee, but it holds systematically.

Moreover, our algorithm for testing the existence of a $k$-cycle passing through a given edge $e$ does not rely on the $\epsilon$-farness assumption. That is, even if there is just a single $k$-cycle passing through $e$, that cycle will be detected by our algorithm.

After the acceptance of the paper, we became aware of the existence of a combinatorial lemma due to Erdős et al. [14], stating the following. Let $V$ be a set of size $n$, and let us fix two integers $p$ and $q$ with $p+q\leq n$. Then, for any set $F\subseteq{\mathcal{P}}(V)$ of subsets of size at most $p$ of $V$, there exists a subset $\widehat{F}$ of $F$ of cardinality at most ${p+q\choose p}$ such that, for every set $C\subseteq V$ of size at most $q$, if there is a set $L\in F$ such that $L\cap C=\emptyset$, then there also exists $\widehat{L}\in\widehat{F}$ such that $\widehat{L}\cap C=\emptyset$. This combinatorial result has been used in different contexts, including the design of sequential parametrized algorithms for the longest path problem [26]. Our technique for detecting cycles can also be viewed as a distributed implementation of this combinatorial lemma.

1.3 Related Work

1.3.1 Property Testing

The property of $H$-freeness has been the subject of a lot of investigation in classical (i.e., sequential) property testing.

In the so-called dense model, most solutions exploit the graph removal lemma, which essentially states that, for every $k$-node graph $H$, and every $\epsilon>0$, there exists $\delta>0$ such that every $n$-node graph containing at most $\delta n^{k}$ (induced) copies of $H$ can be transformed into an (induced) $H$-free graph by deleting at most $\epsilon n^{2}$ edges. This lemma was first proved for the case $k=3$, and later generalized to subgraphs $H$ of any size [13], and further to induced subgraphs [1]. It is possible to exploit this lemma for testing the presence of any (induced or not) subgraph of constant size, in constant time. Notice that $\delta$ is a fast growing function of $\epsilon$ and $k$. The growth of the function was later improved in [3] under some assumptions. For more details on the graph removal lemma, see [10].

Cycle-detection has also been considered in the so-called sparse model. On bounded degree graphs, cycle-freeness can be tested with $O(\frac{1}{\epsilon^{3}}+\frac{d}{\epsilon^{2}})$ queries [22] by a $2$-sided error algorithm, where $d$ is the maximum degree of the graph. However, if we restrict ourselves to $1$-sided error algorithms, then the problem becomes harder. A lower bound of $\Omega(\sqrt{n})$ queries was established in [11]. The same paper presents a tester requiring $\widetilde{O}(poly(\nicefrac{{1}}{{\epsilon}})\sqrt{n})$ queries in arbitrary graphs, and another tester requiring $\widetilde{O}(poly(\nicefrac{{d^{k}}}{{\epsilon}})\sqrt{n})$ queries in graphs with maximum degree $d$ for detecting cycles of length at least $k$. Detecting triangles requires at least $\Omega(n^{\nicefrac{{1}}{{3}}})$ queries, and at most $O(n^{\nicefrac{{6}}{{7}}})$ queries (see [2]). The same lower bound holds for detecting any non bipartite subgraph $H$, and for $2$-sided error algorithms as well. For some specific subgraphs $H$, the lower bound can even be as high as $\Omega(n^{\nicefrac{{1}}{{2}}})$.

1.3.2 Distributed Property Testing

Distributed property testing has been introduced in [6], and fully formalized in [7].

The authors of that latter paper show that, in the dense model, any tester for a non-disjointed property can be emulated in the distributed setting with just a quadratic slowdown, i.e., if a sequential tester makes $q$ queries, then it can be converted into a distributed tester that performs in $O(q^{2})$ rounds. This simulation exploits the fact that any dense tester can be converted to a tester that first chooses some nodes uniformly at random, gathers their edges, and then performs centralized analysis of the obtained data (see [23]).

The authors of [7] also provide distributed testers for the sparse model, showing that it is possible to test triangle-freeness in $O(\nicefrac{{1}}{{\epsilon^{2}}})$ rounds, cycle-freeness in $O(\nicefrac{{1}}{{\epsilon}}\log n)$ rounds, and, in bounded degree graphs, bipartiteness in

[TABLE]

rounds. Their work was inspired by [6], where a constant-time distributed algorithm for finding a linear-size $\epsilon$-near clique is proposed, under the assumption that the graph contains a linear-size $\epsilon^{3}$-near clique. (An $\epsilon$-near clique is a set of nodes where all but an $\epsilon$ fraction of pairs of nodes have edges between them).

The result in [7] regarding testing triangle-freeness was extended in [20], where it is shown that, for every 4-node connected graph $H$, there exists a distributed tester for $H$-freeness performing in $O(\nicefrac{{1}}{{\epsilon^{2}}})$ rounds. Also, [20] provides a proof that the approach in [7, 20] fails to test $C_{k}$-freeness in a constant number of rounds, whenever $k\geq 5$.

1.3.3 Distributed Decision

Distributed property testing fits into the larger framework of distributed decision. The seminal paper [27] was perhaps the first to identify the connection between the ability to locally check the correctness of a solution in a distributed manner, and the ability to design an efficient deterministic distributed algorithm for constructing a correct solution. Since then, there have been a huge amount of contributions aiming at studying variant of distributed decision, in the deterministic setting (see, e.g., [19]), the anonymous setting (see, e.g., [12]), the probabilistic setting (see, e.g., [15, 18]), the non-deterministic setting (see, e.g., [24, 25]), and even beyond (see, e.g., [4, 17]). We refer to [16] for a survey on distributed decision.

1.3.4 Distributed Cycle Detection

Cycle detection has been investigated in various parallel and distributed computing frameworks, in particular for its connection to deadlock detection in routing or databases. We refer to, e.g., [5, 8, 9, 28] for cycle detection in message passing, bulk-synchronization, self-stabilizing, and other models of parallel and distributed computing.

2 Model and Definitions

2.1 The CONGEST Model

We are considering the classical congest model for distributed network computing [29]. The network is modeled as a connected simple graph (no self-loops, and no parallel edges). The nodes of the graph are computing entities exchanging messages along the edges of the graph. Nodes are given arbitrary distinct identities (IDs) in a range polynomial in $n$, in $n$-node networks. Hence, every ID can be stored on $O(\log n)$ bits.

In the congest model, all nodes start simultaneously, and execute the same algorithm in parallel. Computation proceeds synchronously, in a sequence of rounds. At each round, every node

• •

performs some individual computation,

• •

sends messages to neighbors in the network, and

• •

receives messages sent by neighbors.

The main constraint imposed by the congest model is a restriction of the amount of data that can be transferred between neighboring nodes during a round: messages are bounded to be of $O(\log n)$ bits.

The $O(\log n)$-bit bound on the message size enables the transmission of a constant number of IDs between nodes at each round. The congest model is well suited for analyzing the impact of limiting the throughput of a network on its capacity to solve tasks efficiently. The complexity of a distributed algorithm in the congest model is expressed in number of rounds.

In this paper, we are mostly interested in solving tasks locally. Hence, we are mainly focussing on the design of algorithms performing in a constant number of rounds in the congest model.

2.2 Distributed Property Testing

2.2.1 Definition

Let ${\mathcal{P}}$ be a graph property like, e.g., planarity, cycle-freeness, bipartiteness, $C_{k}$-freeness, etc. Let $\epsilon\in(0,1)$. Recall that a graph $G$ is said to be $\epsilon$-far from satisfying ${\mathcal{P}}$ if removing and/or adding at most $\epsilon m$ edges to/from $G$ cannot result in a graph satisfying ${\mathcal{P}}$.

A distributed property testing algorithm for ${\mathcal{P}}$ is a randomized algorithm which performs as follows. Initially, every node is only given its ID as input. After a certain number of rounds, every node must output a value in $\{\mbox{\sf accept},\mbox{\sf reject}\}$. The algorithm is correct if and only if the following two conditions are satisfied.

$\bullet$ if $G$ satisfies ${\mathcal{P}}$, then

[TABLE]

$\bullet$ if $G$ is $\epsilon$-far from satisfying ${\mathcal{P}}$, then

[TABLE]

The algorithm is 1-sided error if, whenever $G$ satisfies ${\mathcal{P}}$, the probability that every node outputs accept equals 1, i.e., if $G$ satisfies ${\mathcal{P}}$, then

[TABLE]

2.2.2 $C_{k}$-Freeness

Let $k\geq 3$. A $k$-node cycle, or simply $k$-cycle for short, consists of $k$ nodes $x_{i}$, and $k$ edges $\{x_{i},x_{i+1\bmod k}\}$, $i=0,\dots,k-1$. Such a graph is denoted by $C_{k}$.

Given a graph $G$, its set of nodes (resp., edges) is denoted by $V(G)$ (resp., $E(G)$). Throughout the paper, $n=|V(G)|$, and $m=|E(G)|$.

Recall that a graph $H$ is a subgraph of a graph $G$ if and only if

[TABLE]

Definition 1

A network $G$ is $C_{k}$-free if and only if $G$ does not contain a $k$-node cycle as a subgraph.

Our objective is the design of efficient distributed property testing algorithms for $C_{k}$-freeness, for all $k\geq 3$.

3 Detecting Cycles

In this section, we establish our main result.

Theorem 1

For every $k\geq 3$, there exists a 1-sided error distributed property testing algorithm for $C_{k}$-freeness performing in $O(\frac{1}{\epsilon})$ rounds in the congest model.

The rest of the section is dedicated to the proof of the theorem. Let us fix $k\geq 3$. We need to show that there exists a distributed tester for $C_{k}$-freeness performing in $O(\frac{1}{\epsilon})$ rounds, satisfying

$\bullet$ if $G$ is $C_{k}$-free, then

[TABLE]

$\bullet$ if $G$ contains a cycle $C_{k}$ then

[TABLE]

Our tester algorithm for detecting $C_{k}$ proceeds in two phases:

determining a candidate edge $e$ susceptible to belong to some cycle $C_{k}$, if any; 2. 2.

checking the existence of a cycle $C_{k}$ passing through $e$.

Only the first phase is randomized, the second phase is fully deterministic.

3.1 Description of Phase 1

Every edge is assigned to its extremity with smallest identity. Every node picks a random integer $r(e)\in[1,m^{2}]$ for each edge $e$ that is assigned to it, called the rank of $e$. (By construction, $O(\log n)$ random bits per edge are sufficient). For each edge $e$, the extremity of $e$ which computed its rank sends $r(e)$ to the other extremity. Then, every node $u$ selects the edge $e_{u}$ of lowest rank among all its incident edges, where ties are broken arbitrarily (e.g., based on the ID of extremities), and starts performing the second phase, which consists in checking whether there exists a cycle $C_{k}$ passing through $e_{u}$.

To avoid congestion, every node performs only instructions of Phase 2 related to the edge with smallest rank it ever become aware of during the execution of the algorithm (again, ties are broken arbitrarily), in a way similar to the prioritized search in [7]. Specifically, if a node $u$ currently involved in checking the existence of a cycle $C_{k}$ passing through $e$ receives a message related to checking the existence of a cycle $C_{k}$ passing through $e^{\prime}\neq e$, then $u$ discards this message if

[TABLE]

and otherwise switches to checking the existence of cycles passing through $e^{\prime}$. This guarantees that no two messages corresponding to checking the existence of a cycle $C_{k}$ passing through two different edges ever traverse an edge in the same direction at the same round. Moreover, if there is a unique edge $e$ with minimum rank, then no nodes discard messages related to checking the existence of a cycle $C_{k}$ passing through $e$, and thus the checking phase for $e$ will not be interrupted.

Before analyzing Phase 1, we now describe Phase 2, which is the core of the property testing algorithm for $C_{k}$-freeness. For simplifying the presentation, let us fix some edge

[TABLE]

and let us describe Phase 2 for edge $e$ only, assuming that no other checks for other edges are running concurrently. Likewise, the reader can assume that $e$ is the unique edge with minimum rank in $G$, which guarantees that the Phase 2 for $e$ will not be slowed down by messages corresponding to Phase 2 applied to other edges.

3.2 Description of Phase 2

We describe the algorithm used to check whether there exists a cycle $C_{k}$ passing through a given edge $e$. The algorithm proceeds in $\lfloor\frac{k}{2}\rfloor$ rounds. At each round $t=1,\dots,\lfloor\frac{k}{2}\rfloor$ of the algorithm, sequences of $t$ IDs are exchanged between nodes participating to the search for $C_{k}$. Every node which receives some sequences at round $t$ concatenates its own ID to each received sequence, and sends the resulting collection of sequences to all its neighbors.

For instance, to detect a $C_{5}$ passing through $e=\{u,v\}$, nodes $u$ and $v$ send their IDs to their neighbors at Round 1 (see Fig. 1). A node may thus receive 0, 1, or 2 IDs depending on whether it is adjacent to none, one, or both nodes $u$ and $v$. Each node $x$ which received at least one of these IDs has now a set ${\mathcal{R}}$ of sequences of the form $(\mbox{\rm ID}(w))$ where $w\in\{u,v\}$. Such node appends its own ID to each sequence, and sends the resulting set of sequences to all its neighbors at Round 2. A node $z$ that, at Round 2, receives a sequence $(\mbox{\rm ID}(u),\mbox{\rm ID}(x))$, and a sequence $(\mbox{\rm ID}(v),\mbox{\rm ID}(y))$ from distinct neighbors $x$ and $y$, respectively, detects the presence of the cycle $(u,x,z,y,v)$.

This “append-and-forward” technique can be trivially extended to detect $C_{k}$, for arbitrary $k\geq 5$. However, a node of high degree may have to forward very many sequences during a round (this is typically the case of a node connected to $u$ and/or $v$ via many vertex-disjoint paths of same length), violating the bandwidth restriction of the congest model.

The main concern of our algorithm is to limit the maximum number of different sequences of IDs to be sent by each node during the execution. Yet, it is crucial that nodes forward sufficiently many sequences of IDs to guarantee detection. For instance, in the graph depicted on Fig. 1, nodes $x$ and $y$ both receive $\mbox{\rm ID}(u)$ and $\mbox{\rm ID}(v)$ at the first round. If $x$ forwards only the sequence $(\mbox{\rm ID}(u),\mbox{\rm ID}(x))$, and $y$ forwards only the sequence $(\mbox{\rm ID}(u),\mbox{\rm ID}(y))$, the 5-cycle will not be detected by $z$.

In other words, discarding too many sequences may prevent the algorithm from detecting the cycle, while forwarding too many sequences overloads the communication links. We show that sending a constant number of sequences is sufficient to guarantee cycle detection whenever these sequences are carefully chosen.

The pseudocode of our algorithm is depicted as Algorithm 1.

3.3 Description of Algorithm 1

Algorithm 1 is essentially of the form “append-and-forward” (cf. Instruction 24), but selects only a few lists to be sent at each round. The “seed” lists are just formed by $\mbox{\rm ID}(u)$ and $\mbox{\rm ID}(v)$ (cf. Instruction 3). The algorithm proceeds in $\lfloor\frac{k}{2}\rfloor$ rounds (cf. the for-loop of Instruction 9). At each round, every node that received non-empty messages collects all IDs that were contained in these messages, distinct from its own ID, in a set ${\mathcal{I}}$ (cf. Instructions 11-13). Then, at round $t$, a set of $k-t$ “fake” IDs are added in ${\mathcal{I}}$ (cf. Instruction 14). Intuitively, these fake IDs represent the yet unknown IDs of nodes which could potentially form a $C_{k}$ together with the nodes of some list received by the current node at this round. In order to form the collection ${\mathcal{S}}$ of lists that will be sent to neighbors at the next round (cf. Instruction 28), the collection ${\mathcal{X}}$ of all possible sets $X$ of $k-t$ IDs are constructed, including fake IDs (cf. Instruction 15).

The core of the algorithm is the construction of ${\mathcal{S}}$ by the Instructions from 16 to 24. Before describing this crucial part of Algorithm 1 in detail, let us complete the description of the final part of the algorithm.

At Round $\lfloor\frac{k}{2}\rfloor$, all lists of IDs sent and received at this round, or received during the previous round, are considered, and stored in a set of lists ${\mathcal{R}}$ (cf. Instructions 32-36). If a node $w$ has two lists $L_{1}$ and $L_{2}$ in ${\mathcal{R}}$ such that

[TABLE]

then Node $w$ outputs “yes”. Before showing that a cycle $C_{k}$ formed by all nodes with IDs in $L_{1}\cup L_{2}\cup\{\mbox{\rm ID}(w)\}$ exists if and only if $|L_{1}\cup L_{2}\cup\{\mbox{\rm ID}(w)\}|=k$, we first return to the core of Algorithm 1, that is the set up of the set of lists ${\mathcal{R}}$.

Construction of the set of lists to be sent at each round.

For comfort and ease of reading, we repeat below the instructions performed by Algorithm 1 for computing the set ${\mathcal{S}}$ of ordered sequences to be sent to all neighboring nodes.

${\mathcal{S}}\leftarrow\emptyset$

for all $L\in{\mathcal{R}}$ **do

**     ${\mathcal{C}}\leftarrow\{X\in{\mathcal{X}}:X\cap L=\emptyset\}$

if ${\mathcal{C}}\neq\emptyset$ then

${\mathcal{S}}\leftarrow{\mathcal{S}}\cup\{L\}$

${\mathcal{X}}\leftarrow{\mathcal{X}}\setminus{\mathcal{C}}$

end if

end for

append $myid$ at the tail of each $L\in{\mathcal{S}}$

Recall that ${\mathcal{R}}$ denotes the set of all ordered sequences $L$ of IDs received at this round, and ${\mathcal{X}}$ denotes the collection of all sets of $k-t$ elements in ${\mathcal{I}}$, where ${\mathcal{I}}$ is the set of all collected IDs at this round, including the fake IDs in $\{-1,-2,\dots,-k+t\}$.

For each sequence $L\in{\mathcal{R}}$ the algorithm takes the decision whether to include $L$ in ${\mathcal{S}}$ or not. For this purpose, the algorithm checks whether there is a set $X\subseteq{\mathcal{I}}$ with $k-t$ elements which does not intersect $L$. If this is the case, such a list $L$ is added to ${\mathcal{S}}$. The intuition is that $L$ (of length $t-1$ at round $t$) may potentially be extended by adding the current node, plus $k-t$ other nodes, so that to form a cycle $C_{k}$.

For instance, Fig. 2 displays the case where

[TABLE]

and

[TABLE]

are considered by some node $z$, depicted as a star $\star$ on the figure. The nodes in $L$ are depicted in light grey, while the nodes in $X$ are depicted in black. Note that $X$ is a set, and the ordering of the $x_{i}$’s on the figure is arbitrary. The list $L$ is placed in ${\mathcal{S}}$ because there are $k-t$ nodes, i.e., those in $X$, which can potentially form a $k$-cycle with $z$ and all the nodes in $L$.

Importantly, the sets $X\in{\mathcal{C}}$ are then removed from ${\mathcal{X}}$. The intuition is that if there is a $k$-cycle formed by the nodes in $L^{\prime}\cup\{z\}\cup X$ for some list $L^{\prime}\in{\mathcal{R}}$ where $z$ is the actual node, then the nodes in $L\cup\{z\}\cup X$ also form a $k$-cycle, and therefore there is no need to keep both $L$ and $L^{\prime}$. Therefore, as soon as $L$ has been identified, all witnesses sets $X\in{\mathcal{C}}$ can safely be removed from ${\mathcal{X}}$.

For instance, considering again the example of Fig. 2, as long as $L$ has been placed in ${\mathcal{S}}$, the set $X$ can be removed from ${\mathcal{X}}$ since it could only be used to identify another sequence

[TABLE]

potentially forming a $k$-cycle with $X$, while we are not interested in enumerating all cycles $C_{k}$ but just in determining whether there is one.

Note here the role of the fake IDs that were added to ${\mathcal{I}}$. First, observe that the first sequence $L\in{\mathcal{R}}$ that is considered in the for-loop (the order in which these sequence are taken is arbitrary) is necessarily placed in ${\mathcal{S}}$. Indeed,

[TABLE]

is in ${\mathcal{X}}$, and for sure does not intersect $L$. Second, notice that the fact that all sets $X\in{\mathcal{C}}$ can be safely removed from ${\mathcal{X}}$ is not obvious if $X$ contains fake IDs because $X$ then does not fully specify the cycle. Nevertheless, we shall show that those sets can still be removed, without preventing the algorithm to detect a cycle, if there is one.

To give a more precise intuition of the use of fake IDs in our algorithm, let us consider a cycle of length $9$, where node IDs are from $1$ to $9$, consecutively around the cycle (hence, the edges are $\{1,2\},\ldots,\{8,9\}$ and $\{1,9\}$. Let us assume that one wants to detect $C_{9}$, starting from the edge {1,9}. Then, in particular, when node $3$ receives the sequence $(1,2)$ from node $2$, we want that node to send the sequence $(1,2,3)$ to node $4$. This is the role of Lines 16-24 in Algorithm 1, where ${\mathcal{R}}$ contains just the sequence $(1,2)$. In Algorithm 1, if one would not add fake IDs to ${\mathcal{I}}$, then ${\mathcal{I}}={1,2}$, and ${\mathcal{X}}$ would become empty as one cannot construct sequences of length $k-t=9-3=6$ using IDs from ${\mathcal{I}}$. As a consequence, ${\mathcal{C}}$ would also be empty as it results from an intersection with the empty set, and we would not add $(1,2)$ to ${\mathcal{S}}$. It would follow that node $3$ does not send any sequence. Instead, if we add the fake IDs $-1,…,-6$ to ${\mathcal{I}}$, then the sequence $(-1,\ldots,-6)$ is in ${\mathcal{X}}$, and since $(1,2)$ is disjoint with $\{-1,\ldots,-6\}$, the sequence $(1,2)$ is added to ${\mathcal{S}}$, and the sequence $(1,2,3)$ will be sent, as desired.

3.4 Analysis of Algorithm 1

We start by proving the correctness of the algorithm, before analyzing its performances.

Lemma 1

For every $t=1,\dots,\lfloor\frac{k}{2}\rfloor$, every sequence $L$ contained in a non-empty set ${\mathcal{S}}$ sent at round $t$ is composed of $t$ distinct IDs, and forms a simple path in the graph with one extremity equal to the sender, and the other equal to $u$ or $v$.

Proof. By induction on $t$. The lemma trivially holds for $t=1$ (cf. Instruction 3). All messages set to be sent at round $t+1$ are constructed by appending the ID of the current node to sequences $L$ received at round $t$ (cf. Instruction 24), and these sequences $L$ do not contain the ID of the current node (cf. Instruction 12). Therefore, every sequence sent at round $t+1$ are composed of $t+1$ distinct IDs. Moreover, by induction, a sequence $L$ received at round $t$ by a node $x$ from a neighboring node $y$ forms a simple path in the graph with one extremity equal to $y$. Therefore, as long as $\mbox{\rm ID}(x)\notin L$ (which is guarantied by Instruction 12), the sequence $L\cup\{\mbox{\rm ID}(x)\}$ forms a simple path in the graph with one extremity equal to $x$. The other extremity remains unchanged, and thus equal to $u$ or $v$. $\Box$

Lemma 2

For any graph $G$, and every edge $e=\{u,v\}$ of $G$, Algorithm 1 running on $G$ satisfies that all nodes output accept if and only if there are no $C_{k}$ passing through the edge $e$.

Proof. Let us assume that some node $w$ outputs reject, and let us show that there is indeed a $k$-cycle passing through $e$. From Instruction 37, this node $w$ satisfies that there exist two sequences $L_{1},L_{2}\in{\mathcal{R}}$ such that

[TABLE]

By Lemma 1, both sequences are simple paths of length at most $\lfloor\frac{k}{2}\rfloor$ from $u$ or $v$ to a neighbor of $w$. Let

[TABLE]

and

[TABLE]

where $\ell\leq\lfloor k/2\rfloor$ and $m\leq\lfloor k/2\rfloor$.

• •

If $k$ is odd, $|L_{1}\cup L_{2}\cup\{\mbox{\rm ID}(w)\}|=k$ implies that $\ell=m=\lfloor k/2\rfloor$, $w$ is distinct from every $x_{i}$ and every $y_{j}$, and every $x_{i}$ is distinct from every $y_{j}$, $i=1,\dots,\ell$, $j=1,\dots,m$. In particular, since $x_{1}\neq y_{1}$, we have $\{x_{1},y_{1}\}=\{u,v\}$. It follows that

[TABLE]

is a $k$-cycle passing through $e$.

• •

If $k$ is even, then we claim that

[TABLE]

or

[TABLE]

Indeed, let us consider two distinct sequences $L$ and $L^{\prime}$ in ${\mathcal{S}}$. Since they are both of length $k/2$, and since they both contain $\mbox{\rm ID}(w)$, we have $|L\cup L^{\prime}\cup\{\mbox{\rm ID}(w)\}|\leq k-1$. Thus, at least a sequence must not be contained in ${\mathcal{S}}$. Moreover, if $|L\cup L^{\prime}\cup\{myid\}|=k$, then at least one of the two sequences must belong to ${\mathcal{S}}$ because the sequences received at round $k/2-1$ are of length $k/2-1$. Hence the claim holds.

So, let us now assume, w.l.o.g., that $L_{1}\in{\mathcal{S}}$ and $L_{2}\not\in{\mathcal{S}}$. It follows that $L_{1}$ is of length $k/2$ and contains $\mbox{\rm ID}(w)$, and that $L_{2}$ is of length $k/2$ without containing $\mbox{\rm ID}(w)$. The equality $|L_{1}\cup L_{2}\cup\{\mbox{\rm ID}(w)\}|=k$ then implies that $w$ is distinct from every $x_{i}$ and every $y_{j}$, and every $x_{i}$ is distinct from every $y_{j}$, $i=1,\dots,\ell$, $j=1,\dots,m$. In particular, since $x_{1}\neq y_{1}$, we have $\{x_{1},y_{1}\}=\{u,v\}$. It follows that

[TABLE]

is a $k$-cycle passing through $e$.

Therefore, for both cases, $k$ even or odd, the existence of a node which outputs reject implies the existence of a cycle passing through $e$.

Conversely, let us assume that there is a $k$-cycle passing through $e$, and let us show that at least one node detects that cycle (i.e., outputs reject). Observe that a modified version of the algorithm where the construction of ${\mathcal{S}}$ in the for-loop of Instruction 17 is replaced by

[TABLE]

clearly detects the cycle. Indeed, at each round $t$, all the possible paths of length $t$ from the edge to the actual node are transmitted. However, there can be too many such paths, and transmitting all of them would not fit with the constraints of the congest model. Hence, some paths are discarded by Algorithm 1. Yet, we show that Algorithm 1 keeps sufficiently many options for detecting the cycle. Let us fix some round $t\in\{2,\dots,\lfloor\frac{k}{2}\rfloor\}$, and a node $w$. Let us consider a discarded sequence

[TABLE]

at $w$. Let us assume that the cycle includes that sequence of nodes, that is the cycle is of the form

[TABLE]

where $\{x_{1},y_{k-t}\}=\{u,v\}$. Since the sequence has been discarded, we have

[TABLE]

where ${\mathcal{X}}$ is the collection of all sets $X$ of $k-t$ IDs in ${\mathcal{I}}$, and ${\mathcal{I}}$ is the collection of all IDs included in at least one sequence in ${\mathcal{R}}$, complemented with the $k-t$ “fake” IDs

[TABLE]

This implies that all sets $X\in{\mathcal{X}}$ that intersect $L$ have been removed from ${\mathcal{X}}$ when considering other sequences in the for-loop. In particular the set

[TABLE]

has been removed when considering another sequence

[TABLE]

Since $L^{\prime}\cap\{y_{1},\ldots,y_{k-t}\}=\emptyset$, we get that there is actually another cycle,

[TABLE]

where $\{z_{1},y_{k-t}\}=\{u,v\}$. Therefore, Algorithm 1 satisfies that, at every round $t\in\{2,\dots,\lfloor\frac{k}{2}\rfloor\}$, if $w$ belongs to a cycle

[TABLE]

passing through $e=\{x_{1},y_{k-t}\}$, and $w$ receives the sequence $x_{1},x_{2},\ldots,x_{t-1}$, then Algorithm 1 guarantees that if $w$ does not send the sequence $x_{1},x_{2},\ldots,x_{t-1},w$ to $y_{1}$, then $w$ necessarily sends another sequence $z_{1},z_{2},\ldots,z_{t-1},w$ to $y_{1}$ where

[TABLE]

is a cycle passing through $e=\{z_{1},y_{k-t}\}$. Therefore, the nodes antipodal to $e$ (that is, the nodes at distance $\lceil\frac{k}{2}\rceil-1$ from $e$ in the cycle) will detect a cycle at round $\lfloor\frac{k}{2}\rfloor$, and will output reject, as desired. $\Box$

In the next lemma, we show that, for a fixed $k$, the messages exchanged during the execution of Algorithm 1 are of constant size.

Lemma 3

For every $t=1,\dots,\lfloor\frac{k}{2}\rfloor$, every message sent by nodes at round $t$ is composed of at most $(k-t+1)^{t-1}$ ordered sequences of $t$ IDs.

Proof. For the ease of notation, we rephrase the statement of the lemma as: For every $t=0,\dots,\lfloor\frac{k}{2}\rfloor-1$, every message sent by nodes at round $t+1$ is composed of at most $(k-t)^{t}$ ordered sequences of $t+1$ IDs.

Let us fix $t\in\{0,\dots,\lfloor\frac{k}{2}\rfloor-1\}$, and a node $w$, and let us focus on round $t+1$. For $i=0,\dots,t$, let us then define property $P_{i}$ stating:

for every set of $t-i$ IDs, $w$ sends at most

$(k-t)^{i}$ sequences that contain that set.

Note that Property $P_{t}$ establishes the lemma.

Property $P_{0}$ stating that, for every set of $t$ IDs, $w$ sends at most one sequence that contains that set, follows from the fact that, in the construction of ${\mathcal{S}}$ in the for-loop of Instruction 17, this set will be sent only once, in one of all its possible orderings.

Let us assume that $P_{i-1}$ holds, and let us establish $P_{i}$. Consider the case where, during the execution of the for-loop of Instruction 17, we already added $(k-t)^{i}$ sequences to ${\mathcal{S}}$ containing the same $t-i$ elements $x_{1},x_{2},\ldots,x_{t-i}$. That is, ${\mathcal{S}}$ contains

[TABLE]

After these sequences have been added to ${\mathcal{S}}$, the remaining sequences in ${\mathcal{X}}$ must contain at least one element of each such sequences. That is, for every $X\in{\mathcal{X}}$,

[TABLE]

or

[TABLE]

Indeed, if a sequence does not contain $x_{1},x_{2},\ldots,x_{t-i}$, then it should contain an element $y_{a,b}$ for each sequence. We can now apply the induction hypothesis to show that the same element $y_{a,b}$ cannot appear more than $(k-t)^{i-1}$ times. Indeed, the sequence $x_{1},x_{2},\ldots,x_{t-i},y_{a,b}$ is of length $t-(i-1)$, and therefore, by induction, it cannot appear more than $(k-t)^{i-1}$ times.

Therefore, since there are $(k-t)^{i}=(k-t)^{i-1}\cdot(k-t)$ sequences in ${\mathcal{S}}$ containing the same $t-i$ elements $x_{1},x_{2},\ldots,x_{t-i}$, Eq. (1) implies that a sequence $X\in{\mathcal{X}}$ must contain $k-t$ different elements. However, sequences in $X$ are of size $k-t-1$. Therefore, the formula in Eq. (1) cannot be satisfied. It follows that, for every $X\in{\mathcal{X}}$,

[TABLE]

Let us now consider another sequence

[TABLE]

taken from ${\mathcal{R}}$. This sequence will not be added to ${\mathcal{S}}$ because every sequence $X\in{\mathcal{X}}$ contains at least one element from $\{x_{1},x_{2},\ldots,x_{t-i}\}$, which implies that $L\cap X\neq\emptyset$. $\Box$

3.5 Proof of Theorem 1

Let us first compute the probability of detecting a cycle in a network which is $\epsilon$-far from being $C_{k}$-free. We exploit the fact that, in such a network, there must be many edge-disjoint copies of $C_{k}$, as stated below:

Lemma 4** ([20])**

Let $H$ be any graph. Let $G$ be an $m$-edge graph that is $\epsilon$-far from being $H$-free. Then $G$ contains at least $\epsilon m/|E(H)|$ edge-disjoint copies of $H$.

Hence, a graph $G$ that is $\epsilon$-far from being $C_{k}$-free contains at least $\epsilon m/k$ edge-disjoint copies of $C_{k}$, i.e., $\epsilon m$ edges belong to edge-disjoint cycles.

Lemma 5

The probability that there is a unique edge with minimum rank after the execution of Phase 1 is at least $1/e^{2}$.

Proof. The probability that there are no collisions while choosing for each edge a random number from $[1,m^{2}]$ is

[TABLE]

where the last inequality holds whenever $m\geq 2$. $\Box$

Let $G$ be a graph that is $\epsilon$-far from being $C_{k}$-free. Let ${\mathcal{E}}$ be the event:

there is a unique edge with minimum rank after the

execution of Phase 1, and this edge belongs to a $k$-cycle.

Combining the previous two lemmas, we get that

[TABLE]

Now, if event ${\mathcal{E}}$ holds, then, by Lemma 2, at least one node will output reject, as desired. To boost the probability of detecting a cycle in a graph that is $\epsilon$-far from being $C_{k}$-free, we repeat the whole process $\frac{e^{2}}{\epsilon}\ln 3$ times. In this way, the probability that ${\mathcal{E}}$ holds in at least one of these repetitions is at least $\nicefrac{{2}}{{3}}$ as desired.

By Lemma 3, each repetition of the whole process of executing Phases 1 and 2 requires a constant number of rounds. This completes the proof of Theorem 1. $\Box$

4 Conclusion

In this paper, we have proved that, for every $k\geq 3$, there exists a 1-sided error distributed property testing algorithm for $C_{k}$-freeness, performing in $O(1/\epsilon)$ rounds. We mention hereafter some possible directions for further work.

It was proved in [20] that, for every graph pattern $H$ with at most 4 nodes, there exists a distributed property testing algorithm for $H$-freeness, performing in constant number of rounds, and the question of whether a distributed property testing algorithm for $H$-freeness exists for every arbitrarily large pattern $H$ was left open in [20]. The techniques in this paper does not seem to extend to arbitrary patterns. To see why, consider $H$ as a $k$-cycle with a chord between two nodes. The pruning technique in Algorithm 1 discarding some sequences of nodes is oblivious to the neighborhood of the nodes in these sequences. Hence, while Algorithm 1 makes sure to keep at least one sequence corresponding to a cycle, if such cycle exists, it may well discard the sequence corresponding to the cycle in $H$, and keep a sequence without a chord. It was also pointed out in [20] that their techniques do not seem to extend to induced subgraphs222A graph $H$ is an induced subgraph of a graph $G$ iff $V(H)\subseteq V(G)$ and $E(H)=E(G[V(H)])$, i.e., for every $(u,v)\in V(H)\times V(H)$, we have $\{u,v\}\in E(H)\iff\{u,v\}\in E(G)$. (In other words, $H$ is isomorphic to the subgraph of $G$ induced by the nodes in $H$).. The same apparently holds for the techniques in this paper. The reasons are the same as for detecting a given graph pattern $H$. Indeed, our pruning mechanism is not adapted to detect an induced cycle. It may well discard a sequence corresponding to the induced cycle, and keep a sequence with chords.

We believe that proving or disproving the existence of distributed property testing algorithms for $H$-freeness, as a subgraph or as an induced subgraph, are potentially challenging but definitely rewarding issues whose study is susceptible to shed new light on the congest model, and, more generally, to improve our understanding of local distributed computing in presence of bandwidth limitation.