Faster and Simpler Distributed Algorithms for Testing and Correcting Graph Properties in the CONGEST-Model

TL;DR

This paper introduces faster distributed algorithms in the CONGEST model for testing and correcting various graph properties, including bipartiteness, cycle-freeness, and $H$-freeness, with improved round complexities over prior work.

Contribution

It presents new, more efficient distributed testing algorithms for multiple graph properties and extends existing methods to broader classes of graphs and properties.

Findings

Optimal bipartiteness tester with $O(rac{ ext{log} n}{ ext{epsilon}})$ rounds.

Efficient algorithms for testing $H$-freeness for connected $H$ of size up to four.

Generalization of $k$-path freeness testing to any tree of order $k$.

Abstract

In this paper we present distributed testing algorithms of graph properties in the CONGEST-model [Censor-Hillel et al. 2016]. We present one-sided error testing algorithms in the general graph model. We first describe a general procedure for converting $\epsilon$-testers with a number of rounds $f(D)$, where $D$ denotes the diameter of the graph, to $O((\log n)/\epsilon)+f((\log n)/\epsilon)$ rounds, where $n$ is the number of processors of the network. We then apply this procedure to obtain an optimal tester, in terms of $n$, for testing bipartiteness, whose round complexity is $O(\epsilon^{-1}\log n)$, which improves over the $poly(\epsilon^{-1} \log n)$-round algorithm by Censor-Hillel et al. (DISC 2016). Moreover, for cycle-freeness, we obtain a \emph{corrector} of the graph that locally corrects the graph so that the corrected graph is acyclic. Note that, unlike a tester, a corrector needs to mend the graph in many places in the case that the graph is far from having the property. In the second part of the paper we design algorithms for testing whether the network is $H$-free for any connected $H$ of size up to four with round complexity of $O(\epsilon^{-1})$. This improves over the $O(\epsilon^{-2})$-round algorithms for testing triangle freeness by Censor-Hillel et al. (DISC 2016) and for testing excluded graphs of size $4$ by Fraigniaud et al. (DISC 2016). In the last part we generalize the global tester by Iwama and Yoshida (ITCS 2014) of testing $k$-path freeness to testing the exclusion of any tree of order $k$. We then show how to simulate this algorithm in the CONGEST-model in $O(k^{k^2+1}\cdot\epsilon^{-k})$ rounds.

Equations

$$\mathrm{P}r\left[I_{v,u}=1\mid C\right]$$

$$=\frac{d(w)-1}{{\sum }_{x\in N(v)}(d(x)-1)}\cdot \frac{1}{d(w)-1}\ge \frac{1}{2m}.$$

Full text

We present one-sided error testing algorithms in the general graph model.

We first describe a general procedure for converting $\varepsilon$-testers with a number of rounds $f(D)$, where $D$ denotes the diameter of the graph, to $O((\log n)/\varepsilon)+f((\log n)/\varepsilon)$ rounds, where $n$ is the number of processors of the network. We then apply this procedure to obtain an optimal tester, in terms of $n$, for testing bipartiteness, whose round complexity is $O(\varepsilon^{-1}\log n)$, which improves over the $\operatorname{Poly}(\varepsilon^{-1}\log n)$-round algorithm by Censor-Hillel et al. (DISC 2016). Moreover, for cycle-freeness, we obtain a corrector of the graph that locally corrects the graph so that the corrected graph is acyclic. Note that, unlike a tester, a corrector needs to mend the graph in many places in the case that the graph is far from having the property.

In the second part of the paper we design algorithms for testing whether the network is $H$-free for any connected $H$ of size up to four with round complexity of $O(\varepsilon^{-1})$. This improves over the $O(\varepsilon^{-2})$-round algorithms for testing triangle freeness by Censor-Hillel et al. (DISC 2016) and for testing excluded graphs of size $4$ by Fraigniaud et al. (DISC 2016).

In the last part we generalize the global tester by Iwama and Yoshida [IY14] of testing $k$-path freeness to testing the exclusion of any tree of order $k$. We then show how to simulate this algorithm in the CONGEST-model in $O(k^{k^{2}+1}\cdot\varepsilon^{-k})$ rounds.

Keywords.

Property testing, Property correcting, Distributed algorithms, CONGEST model.

1 Introduction

In graph property testing [GGR98, GR02] the goal is to design a sequential sublinear algorithm that, given a query access to a graph, decides whether the graph has a given property or is $\varepsilon$-far from having it. By sublinear we mean that the number of queries that the algorithm generates is much smaller than the size of the graph. In the general graph model, a graph, $G=(V,E)$, is $\varepsilon$-far from satisfying a property if at least $\varepsilon\cdot|E|$ edges should be added or removed so that the graph will have the property. Graph property testing in the distributed CONGEST-model has been initiated recently by Censor-Hillel et al. [CHFSV16]. In this setting, each processor locally gathers in a parallel and synchronized fashion information from the network while abiding to a logarithmic bandwidth constraint. When the distributed algorithm terminates, each processor outputs ACCEPT in case the graph (which acts as the network on which the processors communicate) has the tested property (for one-sided error testing), and in case the graph is $\varepsilon$-far from the property, then there is at least one processor that outputs REJECT with probability at least $2/3$. In the distributed setting the goal is to design algorithms with small number of rounds.

In this paper we present improved testers to various properties, such as: is the graph bipartite? Acyclic? Does the graph contain a copy of predetermined tree of size $k$? or other subgraphs of size at most $4$? We obtain these results in three different ways: (1) we demonstrate a procedure that given an $\varepsilon$-tester in the CONGEST-model with linear dependency on the network’s diameter reduces it to a logarithmic dependency in the size of the graph. This technique yields improved algorithm for testing bipartiteness. (2) We directly design improved algorithms for testing whether the graph does not contain a copy of a subgraph of size at most $4$. An important ingredient of testing whether a copy of subgraph of size $4$ exists is the ability to pick u.a.r. a path of length $2$ that emanates from a specific vertex in the CONGEST-model. (3) In the last part we design an $\varepsilon$-tester for the property of being free from copies of a specific tree of size $k$. We then simulate this $\varepsilon$-tester with the same number of rounds as the number of queries of the sequential tester.

1.1 Related Work

Property testing in the distributed CONGEST-model was initiated by Censor-Hillel et al. [CHFSV16]. In [CHFSV16], the distributed testing model was defined as well as various testing algorithms of whether a graph is: triangle-free, cycle-free, or bipartite (i.e., free of odd cycles). Additionally, a logarithmic lower bound was proven for testing bipartiteness and cycle-freeness. Finally, a simulation of sequential (or global) testers for a certain class of graph properties in the dense model is given. This simulation incurs a quadratic blow-up w.r.t. the tester’s number of queries.

Fraigniaud et al. [FRST16] studied testing of excluding subgraphs in the CONGEST-model. In [FRST16] an algorithm for testing whether a graph does not contain a specific subgraph (or any isomorphic copy of it) of size $4$. The number of rounds of this algorithm does not depend on the size of the graph. Fraigniaud et al. [FRST16] also consider the problem of testing whether a graph excludes subgraphs of size $k\geq 5$ (e.g., $C_{5}$ or $K_{5}$). For these properties, they present a “hard” family of graphs for which some “natural” property testing algorithms have a round complexity that depends on the size of the graph.

Our notion of correction is inspired by work on local reconstruction of graph properties (see for example [CGR13] and [KPS13]). However, we note that our definition of correction does not assume anything on the input graph. In particular, we do not assume that it is close to having the required property.

1.2 Our Contributions

We design and analyze distributed testers in the distributed CONGEST-model all of which work in the general graph model. In this model, a graph $G=(V,E)$ is called $\varepsilon$-far from having a property $\mathcal{P}$, if one must remove or add at least $\varepsilon|E|$ edges from $G$ in order to obtain the property $\mathcal{P}$.

Diameter dependency reduction and its Applications.

In Section 3 we describe a general procedure for converting $\varepsilon$-testers with $f(D)$ rounds, where $D$ denotes the diameter of the graph to a $O((\log n)/\varepsilon)+f((\log n)/\varepsilon)$ rounds, where $n$ is the number of processors of the network. We then apply this procedure to obtain an $\varepsilon$-tester for testing whether a graph is bipartite. The improvement of this tester over state of the art is twofold: (a) the round complexity is $O(\varepsilon^{-1}\log n)$, which improves over the $\operatorname{Poly}(\varepsilon^{-1}\log n)$-round algorithm by Censor-Hillel et al. [CHFSV16, Thm. 5.2], and (b) our tester works in the general model while [CHFSV16] works in the more restrictive bounded degree model. Moreover, the number of rounds of our bipartiteness tester meets the $\Omega(\log n)$ lower bound by [CHFSV16, Thm. 7.3], hence our tester is asymptotically optimal in terms of $n$. We then apply this “compiler” to obtain a cycle-free tester with number of rounds of $O(\varepsilon^{-1}\cdot\log n)$, thus revisiting the result by [CHFSV16, Thm. 6.3]. The last application that we consider is “how to obtain a corrector of the graph by using this machinery?” Namely, how to produce a an algorithm that locally corrects the graph so that the corrected graph satisfies the property. For cycle-freeness, we are able to obtain also a corrector. Note that, unlike a tester, a corrector needs to mend the graph in many places in the case that the graph is far from having the property.

Testers for $H$-freeness for $|V(H)|\leq 4$.

In Section 4 we design algorithms for testing (in the general graph model) whether the network is $H$-free for any connected $H$ of size up to four with round complexity of $O(\varepsilon^{-1})$. By $H$-free we mean that there is no sub-graph $H^{\prime}$ of $G$ such that $H$ is isomorphic to $H$. This improves over the $O(\varepsilon^{-2})$-round algorithms for testing triangle freeness by Censor-Hillel et al. [CHFSV16, Thm. 4.1] and for testing excluded graphs of size $4$ by Fraigniaud et al. [FRST16, Thm. 1].

Testers for tree-freeness.

In Section 5 we first generalize the global tester by Iwama and Yoshida [IY14] of testing $k$-path freeness to testing the exclusion of any tree, $T$, of order $k$. Note that in this part of the paper we do not make any assumption of the size of the tree, e.g., $k$ can be larger than $4$. Our tester has a one sided error and it works in the general graph model with random edge queries. We, then, show how to simulate this algorithm in the CONGEST-model in $O(k^{k^{2}+1}\cdot\varepsilon^{-k})$ rounds.

2 Computational Models

Notations.

Let $G=(V,E)$ denote a graph, were $V$ is the set of vertices and $E$ is the set of edges. Let $n\triangleq|V(G)|$, and let $m\triangleq|E(G)|$. For every $v\in V$, let $N_{G}(v)\triangleq\{u\in V\mid\{u,v\}\in E\}$ denote the neighborhood of $v$ in $G$. For every $v\in V$, let $d_{G}(v)\triangleq|N_{G}(v)|$ denote the degree of $v$. When the graph at hand is clear from the context we omit the subscript $G$.

2.1 Distributed CONGEST-Model

Computation in the distributed CONGEST-model [Pel00] is done as follows. Let $G=(V,E)$ denote a network where each vertex is a processor and each edge is a communication link between its two endpoints. Each processor is input a local input. Each processor $v$ has a distinct ID - for brevity we say that the ID of processor $v$ is simply $v$.111In this paper we focus on randomized algorithms, hence one can omit the assumption that each processor has a distinct ID. The computation is synchronized and is measured in terms of rounds. In each round (1) each processor does a local computation, and then (2) sends (different) messages of $O(\log n)$ bits to each of its neighbors (or a possible “empty message”). After the last round all the processors stop and output a local output.

2.2 (Global) Testing Model

Graph property testing [GGR98, GR02] is defined as follows. Let $G=(V,E)$ denote a graph. We assume that for each $v\in V$ there is an arbitrary order on its set of neighbors. Let $\cal P$ denote a graph property, e.g., the graph is cycle-free, the graph is bipartite, etc. We say that a graph $G$ is $\varepsilon$-far (in the general graph model) from having the property $\cal P$ if at least $\varepsilon\cdot m$ edges $E^{\prime}$ should be added or removed from $E(G)$ so as to obtain the property ${\cal P}$.

An algorithm in this model is given a query access to $G$ of the form: (1) what is the degree of $v$ for $v\in V$? (2) who is $i$th neighbor of $v\in V$?

We say that an algorithm is a $\varepsilon$-tester for property ${\cal P}$, one sided, in the general graph model if given query access to the graph $G$ the algorithm ACCEPTS the graph $G$ if $G$ has the property $\cal P$, i.e, completeness, and REJECTS the graph $G$ with probability at least $2/3$ if $G$ is $\varepsilon$-far from having the property $\cal P$, i.e., soundness.

The complexity measure of this model is the number of queries made to $G$. Usually, the goal is to design an $\varepsilon$-tester with $o(n)$ number of queries.

In Section 5 an additional query type is allowed of random edge query where an edge $e$ is picked u.a.r. from $E$.

2.3 Distributed Testing in the CONGEST-model

Let $G=(V,E)$ be a graph and let ${\cal P}$ denote a graph property. We say that a randomized distributed CONGEST algorithm is an $\varepsilon$-tester for property ${\cal P}$ in the general graph model [CHFSV16] if when $G$ has the property ${\cal P}$ then all the processors $v\in V$ output ACCEPT, and if $G$ is $\varepsilon$-far from having the property ${\cal P}$, then there is a processor $v\in V$ that outputs REJECT with probability at least $2/3$.

2.4 Distributed Correcting

In this section we define correction in the distributed setting. We then explain how to obtain correction for the property of cycle-freeness.

Definition 1**.**

A graph property ${\cal P}$ is edge-monotone if $G\in{\cal P}$ and if $G^{\prime}$ is obtained from $G$ by the removal of edges, then $G^{\prime}\in{\cal P}$.

Definition 2**.**

In the distributed CONGEST-model, we say that an algorithm is an $\varepsilon$-corrector for an edge-monotone property $\mathcal{P}$ if the following holds.

Let $G=(V,E)$ denote the network’s graph. When the algorithm terminates, each processor $v$ knows which edges in $E$, that incident to $v$, are in the set of deleted edges $E^{\prime}\subseteq E$. 2. 2.

$G(V,E\setminus E^{\prime})$* is in $\mathcal{P}$.* 3. 3.

$|E^{\prime}|\leq dist(G,\mathcal{P})+\varepsilon|E|$, where $dist(G,\mathcal{P})$ denotes the minimum number of edges that should be removed from $G$ in order to obtain the property $\mathcal{P}$.

3 Reducing the Dependency on the Diameter and Applications

In this section we present a general technique that reduces the dependency of the round complexity on the diameter. The technique is based on graph decompositions defined below.

Definition 3** ([MPX13]).**

*Let $G=(V,E)$ denote an undirected graph. A $(\beta,d)$-decomposition of $G$ is a partition of $V$ into disjoint subsets $V_{1},\ldots,V_{k}$ such that

(i) For all $1\leq i\leq\ell$, $\operatorname{diam}(G[V_{i}])\leq d$, where $G[V_{i}]$ is the vertex induced subgraph of $G$ that is induced by $V_{i}$.

(ii) The number of edges with endpoints belonging to different subsets is at most $\varepsilon\cdot|E|$. We refer to these as cut-edges of the decomposition.

Note that the diameter constraint refers to strong diameter, in particular, each induced subgraph $G[V_{i}]$ must be connected.

Algorithms for $(\varepsilon,(\log n)/\varepsilon)$-decompositions were developed in many contexts (e.g., parallel algorithms [ABCP92, BGK*+*14, MPX13]). An implementation in the CONGEST-model can be derived from the algorithm in [EN17] for constructing spanners. Specifically, we get the following as a corollary from [EN17].

Corollary 1**.**

A $(\varepsilon,O(\log n/\varepsilon))$-decomposition can be computed in the randomized CONGEST-model in $O((\log n)/\varepsilon)$ rounds with probability at least $1-1/\operatorname{Poly}(n)$.

A nice feature of the algorithm based on random exponential shifts is that at the end of the algorithm, there is a spanning BFS-like rooted tree $T_{i}$ for each subset $V_{i}$ in the decomposition. Moreover, each vertex $v\in V_{i}$ knows the center of $T_{i}$ as well as its parent in $T_{i}$. In addition, every vertex knows which of the edges incident to it are cut-edges.

The following definition captures the notion of connected witnesses against a graph satisfying a property.

Definition 4** ([CHFSV16]).**

A graph property ${\cal P}$ is non-disjointed if for every witness $G^{\prime}$ against $G\in{\cal P}$, there exists an induced subgraph $G^{\prime\prime}$ of $G^{\prime}$ that is connected such that $G^{\prime\prime}$ is also a witness against $G\in{\cal P}$.

The main result of this section is formulated in the following theorem. We refer to a distributed algorithm in which all vertices accept iff $G\in{\cal P}$ as a verifier for ${\cal P}$.

Theorem 2**.**

Let ${\cal P}$ be an edge-monotone non-disjointed graph property that can be verified in the CONGEST-model in $O(\operatorname{diam}(G))$ rounds. Then there is an $\varepsilon$-tester for ${\cal P}$ in the randomized CONGEST-model with $O((\log n)/\varepsilon)$ rounds.

Proof.

The algorithm tries to “fix” $G$ so that it satisfies ${\cal P}$ by removing less than $\varepsilon\cdot m$ edges. The algorithm consists of two phases. In the first phase, an $(\varepsilon^{\prime},O((\log n)/\varepsilon^{\prime})$ decomposition is computed in $O((\log n)/\varepsilon^{\prime})$ rounds, for $\varepsilon^{\prime}=\varepsilon/2$. The algorithm removes all the cut-edges of the decomposition. (There are at most $\varepsilon\cdot m/2$ such edges.) In the second phase, in each subgraph $G[V_{i}]$, an independent execution of the verifier algorithm for ${\cal P}$ is executed. The number of rounds of the verifier in $G[V_{i}]$ is $O(\operatorname{diam}(G[V_{i}])=O((\log n)/\varepsilon)$.

We first prove completeness. Assume that $G\in{\cal P}$. Since ${\cal P}$ is an edge-monotone property, the deletion of the cut-edges does not introduce a witness against ${\cal P}$. This implies that each induced subgraph $G[V_{i}]$ does not contain a witness against ${\cal P}$, and hence the verifier do not reject, and every vertex accepts.

We now prove soundness. If $G$ is $\varepsilon$-far from ${\cal P}$, then after the removal of the cut-edges (at most $\varepsilon m/2$ edges) property ${\cal P}$ is still not satisfied. Let $G^{\prime}$ be a witness against the remaining graph satisfying ${\cal P}$. Since property ${\cal P}$ is non-disjointed, there exists a connected witness $G^{\prime\prime}$ in the remaining graph. This witness is contained in one of the subgraphs $G[V_{i}]$, and therefore, the verifier that is executed in $G[V_{i}]$ will reject, hence at least one vertex rejects, as required. ∎

We remark that if the round complexity of the verifier is $f(\operatorname{diam}(G),n)$ (e.g., $f(\Delta,n)=\Delta+\log n$), then the round complexity of the $\varepsilon$-tester is $O((\log n)/\varepsilon)+f((\log n)/\varepsilon,n)$. This follows directly from the proof.

Extensions to $\varepsilon$-Testers.

The following “bootstrapping” technique can be applied. If there exists an $\varepsilon$-tester in the CONGEST-model with round complexity $O(\operatorname{diam}(G))$, then there exists an $\varepsilon$-tester with round complexity $O((\log n)/\varepsilon)$. The proof is along the same lines, expect that instead of a verifier, an $\varepsilon^{\prime}$-tester is executed in each subgraph $G[V_{i}]$. Indeed, if $G$ is $\varepsilon$-far from ${\cal P}$, then, by an averaging argument, there must exist a subset $V_{i}$ such that $G[V_{i}]$ is $\varepsilon^{\prime}$-far from ${\cal P}$. Otherwise, we could “fix” all the parts by deleting at most $\varepsilon^{\prime}\cdot m$ edges, and thus “fix” $G$ by deleting at most $2\varepsilon^{\prime}\cdot m=\varepsilon m$ edges, a contradiction.

3.1 Testing Bipartiteness

Theorem 2 can be used to test whether a graph is bipartite or $\varepsilon$-far from being bipartite. A verifier for bipartiteness can be obtained by attempting to $2$-color the vertices (e.g., BFS that assigns alternating colors to layers). In our special case, each subgraph $G[V_{i}]$ has a root which is the only vertex that initiates the BFS. In the general case, one would need to deal with “collisions” between searches, and how one search “kills” the other searches initiated by vertices of lower ID.

3.2 Testing Cycle-freeness

Theorem 2 can be used to test whether a graph is acyclic or $\varepsilon$-far from being acyclic. As in the case of bipartiteness, any scan (e.g., DFS, BFS) can be applied. A second visit to a vertex indicates a cycle, in which case the vertex rejects.

Corollary 3**.**

There exists an $\varepsilon$-tester in the randomized CONGEST-model for bipartiteness and cycle-freeness with round complexity $O((\log n)/\varepsilon)$.

3.3 Corrector for Cycle-Freeness

Our $\varepsilon$-testers for testing cycle freeness can be easily converted into $\varepsilon$-correctors by removing the following edges: (1) All the cut-edges are removed. (2) In each $G[V_{i}]$, all the edges which are not in the BFS-like spanning tree $T_{i}$ are removed (in order to maintain consistency with the same spanning tree one needs to define a consistent way for breaking ties, e.g., by the ID of the vertices).

Therefore, the total number of edges that we keep is at most $|V|+\varepsilon|E|$.

Theorem 4**.**

There exists an $\varepsilon$-corrector for cycle-freeness in the randomized CONGEST-model with round complexity $O((\log n)/\varepsilon)$.

4 Testing $H$-freeness in $\Theta(1/\varepsilon)$ Rounds for $|V(H)|\leq 4$

4.1 Testing Triangle-freeness

In this section we present an $\varepsilon$-tester for triangle-freeness that works in the CONGEST-model. The number of rounds is $O(1/\varepsilon)$.

Consider a violating edge $\{A,B\}$ and a corresponding triangle $ABC$ in the graph $G=(V,E)$. This triangle can be detected if $A$ tells $B$ about a neighbor $C\in N(A)$ with the hope that $C$ is also a neighbor of $B$. Vertex $B$ checks that $C$ is also its neighbor, and if it is, then the triangle $ABC$ is detected. Hence, $A$ would like to send to $B$ the name of a vertex $C$ such that $C\in N(A)\cap N(B)$. Since $A$ can discover $N(A)$ in a single round, it proceeds by telling $B$ about a neighbor $C\in N(A)\setminus\{B\}$ chosen uniformly at random. Let $M_{{A}\rightarrow{B}}$ denote the random neighbor that $A$ reports to $B$. A listing of the distributed $\varepsilon$-tester for triangle-freeness appears as Algorithm 1. Note that all the messages $\{M_{{A}\rightarrow{B}}\}_{(A,B)\in E}$ are independent, and that the messages are re-chosen for each iteration.

Claim 5**.**

Let $\{A,B\}$ be a violating edge, then ${\mathrm{P}r}\left[M_{{A}\rightarrow{B}}\in N(B)\right]\geq 1/m$.

Proof.

Let $ABC$ be a triangle which is a witness for the violation of $\{A,B\}$. Since $ABC$ is a triangle, $C\in N(A)\cap N(B)$, and ${\mathrm{P}r}\left[M_{{A}\rightarrow{B}}\in N(B)\right]\geq 1/d(A)\geq 1/m$. ∎

Theorem 6**.**

Algorithm 1 is an $\varepsilon$-tester for triangle-freeness.

Proof.

Completeness: If $G$ is triangle free then Line 1 is never satisfied, hence for every $v$ Algorithm 1 terminates at Line 1.

Soundness: Let $G=(V,E)$ be a graph which is $\varepsilon$-far from being triangle free. Therefore there exist at least $\varepsilon\cdot m$ edges, each belonging to at least one triangle. Hence, the probability of not detecting any of these triangles in a single iteration is at most $(1-1/m)^{\varepsilon m}$. The reject probability is amplified to $2/3$ by setting the number of iterations to be $\Theta(1/\varepsilon)$. ∎

4.2 Testing $C_{4}$-freeness in $\Theta(1/\varepsilon)$ Rounds

In this section we present an $\varepsilon$-tester in the CONGEST-model for $C_{4}$-freeness that runs in $O(1/\varepsilon)$ rounds.

Uniform Sampling of $2$-paths.

Let $P_{2}(v)$ denote the set of all paths of length $2$ that start at $v$. The algorithm is based on the ability of each vertex $v$ to uniformly sample a path from $P_{2}(v)$. How many paths in $P_{2}(v)$ start with the edge $(v,w)$? Clearly, there are $(d(w)-1)$ such paths. Hence the first edge should be chosen according to the degree distribution over $N(v)$ defined by $\pi^{v}(w)\triangleq(d(w)-1)/\sum_{x\in N(v)}(d(x)-1)$. Moreover, for each $x\in N(w)\setminus\{v\}$, the (directed) edge $(w,x)$ appears exactly once as the second edge of a path in $P_{2}(v)$. Hence, given the first edge, the second edge is chosen uniformly.

This implies that $v$ can pick a random path $p\in P_{2}(v)$ as follows: (1) Each neighbor $w\in N(v)$ sends $v$ a uniformly randomly chosen neighbor $B_{v}(w)\in N(w)\setminus\{v\}$. The edge $(w,B_{v}(w))$ is a candidate edge for the second edge of $p$. (2) $v$ picks a neighbor $A(v)\in N(v)$ where $A(v)\sim\pi^{v}$. The random path $p$ is $p=\langle v,A(v),B_{v}(A(v))\rangle$, and it is uniformly distributed over $P_{2}(v)$.

In the algorithm, vertex $v$ reports a path to each neighbor. We denote by $p_{u}(v)$ the path in $P_{2}(v)$ that $v$ reports to $u\in N(v)$. This is done by independently picking neighbors $A_{u}(v)\in N(v)$, where each $A_{u}(v)\sim\pi^{v}$. Hence, the path that $v$ reports to $u$ is $p_{u}(v)\triangleq\langle v,A_{u}(v),B_{v}(A_{u}(v))\rangle$ Algorithm 2 uses this process for reporting paths of length $2$. Interestingly, these paths are not independent, however for the case of edge disjoint copies of $C_{4}$, their “usefulness” in detecting copies of $C_{4}$ turns out to be independent (see Lemma 7).

Detecting a Cycle.

Consider a copy $C=(v,w,x,u)$ of $C_{4}$ in $G$. If the $2$-path $p_{u}(v)$ that $v$ reports to $u$ is $p_{u}(v)=(v,w,x)$, then $u$ can check whether the last vertex $x$ in $p_{u}(v)$ is also in $N(u)$. If $x\in N(u)$, then the copy $C$ in $G$ of $C_{4}$ is detected. (The vertex $u$ also needs to verify that $w\neq u$.)

Description of the Algorithm.

The $\varepsilon$-tester for $C_{4}$-freeness is listed as Algorithm 2. In the first round, each vertex $v$ learns its neighborhood $N(v)$ and the degree of each neighbor. The for-loop repeats $t=O(1/\varepsilon)$ times. Each iteration consists of three rounds. In the first round, $v$ independently draws fresh values for $A_{u}(v)$ and $B_{u}(v)$ for each of its neighbors $u\in N(v)$, and sends $B_{u}(v)$ to $u$. In the second round, for each neighbor $u\in N(v)$, $v$ sends the path $\langle v,A_{u}(v),B_{v}(A_{u}(v))\rangle$. In the third round, $v$ checks if it received a path $\langle w,a,b\rangle$ for a neighbor $w\in N(v)$ where $a\neq v$ and $b\in N(v)$. If this occurs, then $(v,w,a,b)$ is a copy of $C_{4}$, and vertex $v$ rejects. If $v$ did not reject in all the iterations, then it finally accepts.

Analysis of the Algorithm.

Definition 5**.**

We say that $p_{u}(v)$ is a success (wrt $C=(v,w,x,u)$) if $p_{u}(v)=(v,w,x)$. Let $I_{v,u}$ denote the indicator variable of the event that $p_{u}(v)$ is a success.

Lemma 7**.**

Let $\{C^{j}(v_{j},w_{j},x_{j},u_{j})\}_{j\in J}$ denote a set of edge-disjoint copies of $C_{4}$ in $G$. Then the random variables $I_{v_{j},u_{j}}$ are independent.

Proof.

The event $I_{v,u}=1$ occurs iff $A_{u}(v)=w$ and $B_{v}(w)=x$. Both $A_{u}(v)$ and $B_{v}(w)$ are random variables assigned to (directed) edges. By construction, all the random variables $\{A_{u}(v)\}_{(u,v\in E}\cup\{B_{v}(w)\}_{(v,w)\in E}$ are independent. Since the cycles are edge-disjoint, the lemma follows. ∎

Claim 8**.**

$\Pr[I_{v,u}=1\mid C]\geq 1/(2m)$.

Proof.

The path $p_{u}(v)$ equals $(v,w,x)$ iff $A_{u}(v)=w$ and $B_{v}(w)=x$. As $A_{u}(v)$ and $B_{v}(w)$ are independent, we obtain

[TABLE]

∎

Claim 9**.**

If a graph $G$ is $\varepsilon$-far from being $C_{4}$-free, then it contains at least $\varepsilon\cdot m/4$ edge-disjoint copies of $C_{4}$.

Proof.

Consider the following procedure for “covering” all the copies of $C_{4}$: while the graph contains a copy of $C_{4}$, delete all four edges of the copy. When the procedure ends, the remaining graph is $C_{4}$-free, hence at least $\varepsilon m$ edges were removed. The set of deleted copies of $C_{4}$ is edge disjoint and hence contains at least $\varepsilon m/4$ copies of $C_{4}$. ∎

Theorem 10**.**

Algorithm 2 is an $\varepsilon$-tester for $C_{4}$-freeness. The round complexity of the algorithm is $\Theta(1/\varepsilon)$ and in each round no more than $O(\log n)$ bits are communicated along each edge.

Proof.

Completeness: If $G$ is $C_{4}$-free then Line 2 is never satisfied, hence for every $v$ Algorithm 2 terminates at Line 2.

Soundness: Let $G=(V,E)$ be a graph which is $\varepsilon$-far from being $C_{4}$-free. Therefore, there exist $\ell\triangleq\varepsilon m/4$ edge disjoint copies of $C_{4}$ in $G$. Denote these copies by $\{C^{1},\ldots,C^{\ell}\}$, where $C^{j}=(v_{j},w_{j},w_{j},u_{j})$. In each iteration, the cycle $C^{j}$ is detected if $I_{v_{j},u_{j}}=1$, which (by Claim 8) occurs with probability at least $1/(2m)$. The cycles $\{C^{j}\}_{j}$ are edge-disjoint, hence, by Lemma 7, the probability that none of these cycles is detected is at most $(1-1/(2m))^{\ell}$. The iterations are independent, and hence the probability that all the iterations fail to detect one of these cycles is at most $(1-1/(2m))^{\ell\cdot t}$. Since $\ell=\varepsilon m/4$, setting $t=16/\varepsilon$ reduces the probability of false accept to at most $1/3$, as required. ∎

Extending Algorithm 2.

The algorithm can be easily extended to test $H$-freeness for any connected $H$ over four nodes. If $H$ is a $K_{1,3}$ then clearly $H$-freeness can be tested in one round. Otherwise, $H$ is Hamiltonian and can be tested by simply sending an additional bit in the message sent in Line 2 of the algorithm. The additional bit indicates whether $v$ is connected to $B_{v}(A_{u}(v))$. Given this information, $u$ can determine the subgraph induced on $\{u,v,A_{u}(v),B_{v}(A_{u}(v))\}$, and hence rejects if $H$ is a subgraph of this induced subgraph. Therefore we obtain the following theorem.

Theorem 11**.**

There is an algorithm which is an $\varepsilon$-tester for $H$-freeness for any connected $H$ over $4$ vertices. The round complexity of the algorithm is $\Theta(1/\varepsilon)$ and in each round no more than $O(\log n)$ bits are communicated along each edge.

5 Testing $T$-freeness for any tree $T$

In this section we first generalize the tester by Iwama and Yoshida [IY14] of testing $k$-path freeness to testing the exclusion of any tree, $T$, of order $k$. Our tester has a one sided error and it works in the general graph model with random edge queries. We, then, show how to simulate this algorithm in the CONGEST- model in $O(k^{k^{2}+1}\cdot\varepsilon^{-k})$ rounds. We assume that the vertices of $T$ are labeled by $v_{0},\ldots,v_{k-1}$.

5.1 Global Algorithm Description and Analysis

Global Algorithm Description.

The algorithm by Iwama and Yoshida [IY14] for testing $k$-path freeness proceeds as follows. An edge is picked u.a.r. and an endpoint, $v$, of the selected edge,is picked u.a.r. A random walk of length $k$ is performed from $v$, if a simple path of length $k$ is found then the algorithm rejects. The analysis in [IY14] shows that this process has a constant probability (depends only on $k$ and $\varepsilon$) to find a $k$-path in an $\varepsilon$-far from $k$-path freeness graph.

We generalize this tester in the following straightforward manner. We pick a random vertex $v$ as in the above-mentioned algorithm. The vertex $v$ is a candidate for being the root of a copy of $T$. For the sake of brevity we denote the (possible) root of the copy of $T$ also by $v_{0}$. From $v$ we start a “DFS-like” revealing of a tree which is a possible copy of $T$ with the first random vertex acting as its root. DFS-like means that we scan a subgraph of $G$ starting from $v$ as follows: the algorithm independently and randomly selects $d_{T}(v_{0})$ neighbors (out of the possible $d_{G}(v)$) and recursively scans the graph from each of these randomly chosen neighbors. While scanning, if we encounter any vertex more than once then we abort the process (we did not find a copy of $T$). If the process terminates, then this implies that the algorithm found a copy of $T$. In order to obtain probability of success of $2/3$ the above process is repeated $t=f(\varepsilon,k)$ times. The listing of this algorithm appears in Algorithm 3.

Global Algorithm Analysis.

Theorem 12**.**

Algorithm 3 is a global $\varepsilon$-tester, one-sided error for $T$-freenes. The query complexity of the algorithm is $O\left(k^{k^{2}+1}\cdot\varepsilon^{-k}\right)$. The algorithm works in the general graph model augmented with random edge samples.

Proof.

We closely follow the analysis approach by Iwama and Yoshida [IY14]. If the input graph $G$ does not contain a copy of $T$ then the $\varepsilon$-tester will not “find” any copy, and will return ACCEPT.

Let $G$ be $\varepsilon$-far from being $T$-free. This implies that there are at least $\ell=\varepsilon m/(k-1)$ edge disjoint copies of $T$ (otherwise contradicting the assumption that $G$ is $\varepsilon$-far being $T$-free). Let $\alpha=\{T_{1},\ldots T_{\ell}\}$ denote such set of edge disjoint copies of $T$. Note that two trees in $\alpha$ might intersect in one of their vertices. Recall that $T$ is labeled by $v_{0},\ldots,v_{k-1}$. For the sake of the analysis we consider a labeling of the vertices of $G$ where each vertex has a label in $\{v_{j}\mid j\in[k-1]\}$. We say that a copy of $T$ in $\alpha$ is labeled correctly if the labeled $T$ and its labeled copy are the same (note that this is a more restrictive requirement then asking for an isomorphic mapping between the two objects). We consider a subset of $\alpha$ which are the copies of $T$ which are labeled correctly, which we denote by $\alpha^{c}$. Note that from linearity of expectation there exists a labeling such that the size of $\alpha^{c}$ is at least $\varepsilon m/\left((k-1)\cdot k^{k}\right)$ - we fix our labeling to this one. Define $\beta\triangleq\varepsilon/\left((k-1)\cdot k^{k}\right)$.

We now “sparsify” our set of trees even more. We proceed in iterations, initially $\alpha_{0}^{c}=\alpha^{c}$ and define $\gamma\triangleq\beta/4$. We continue to the $i$-th iteration as long as there exists a vertex, $y_{i}$, in $\alpha_{i-1}^{c}$ such that the number of copies of $T$ in $\alpha_{i-1}^{c}$ that $y_{i}$ belongs to, is less than $\gamma\cdot d_{G}(y)$. In this case we obtain $\alpha_{i}^{c}$ from $\alpha_{i-1}^{c}$ by removing from $\alpha_{i-1}^{c}$ all the trees that contain $y_{i}$. Note that this results in a deletion of at most $2\gamma\cdot|E(G)|$ copies of $T$ from $\alpha^{c}$, as each vertex gets removed at most once. Therefore, at the last iteration, we obtain in this way the set $\alpha^{*}$ which contains at least $(\beta/2)\cdot m$, edge-disjoint, correctly colored, copies of $T$.

We now focus on the copies of $T$ in $\alpha^{*}$. Fix an iteration of Algorithm 3, and consider the event that on Line 3, the starting vertex, $v$, is a vertex in $\alpha^{*}$ which is labeled by $v_{0}$. The probability that this event occurs is at least $\beta/4$. This follows from the fact that there are at least $(\beta/2)\cdot m$ edges in $\alpha^{*}$ in which one of their endpoints is labeled by $v_{0}$. Conditioned on this event, the probability that $u_{1},\ldots,u_{\ell}$, that are chosen in Line 5.1 of Procedure 5.1, are in $\alpha^{*}$ and their labels are $v_{i_{1}},\ldots,v_{i_{\ell}}$, respectively, is at least $\gamma^{\ell}$. Therefore, by an inductive argument, the probability that the algorithm finds $T$ is at least $(\beta/4)\cdot\gamma^{k-1}=\Omega(\varepsilon^{k}/(k^{k^{2}}))$, for each iteration. Since the number of iterations is $\Theta(k^{k^{2}}/\varepsilon^{k})$, the algorithm rejects $G$ with probability at least $2/3$. ∎

5.2 Simulating the Global tester in the CONGEST-​ model

In order to simulate the above global tester in the CONGEST-model, we first need to show how to simulate a random choice of the initial vertex. Note, that in the distributed setting we are interested in the case where $|E(G)|\geq|V(G)|-1$, hence in Line 5.1 of Algorithm 3, one can simply pick a vertex uniformly at random.

Distributed CONGEST Simulation.

The simulation proceeds in three stages, as follows.

Random ranking assignment. First, each vertex $v$ picks a random rank (independently), denoted by $r(v)$, to be a uniform random number in $[n^{2}]$.

Labeling “competition” phase. Let us call the vertex $v_{0}$ the vertex at level $1$, its children the vertices at level $2$ and so on. Now, at the first round: each vertex label itself as $v_{0}$, picks random neighbors as in Line 5.1 of Algorithm 3 and sends to each selected vertex its respective label. At the next round, each vertex $v$ picks the label that was assigned to it by the vertex with the highest rank, which we refer to as the root. If $v$’s label is of level $2$ then it continues by simulating Procedure 5.1. Specifically, it selects random neighbors and their respective labels and send to each selected neighbor a message with the respective label and the rank of its root. And so this process continues for $k$ rounds.

Labeling verification phase. Now, one needs to report to each root if it succeeded in finding $T$. This can be achieved in additional $k$ rounds: in rounds $i$ all the vertices that were assigned with label from level $i$ send their parent in the revealed tree, whether they succeeded or not, that is, a leaf reports on success if it was not labeled more than once by the respective root, and an internal node reports on success if all its children report on success and if it was not labeled more than once by the respective root. The correctness of the simulations follows from the fact that the messages that are originated from the vertex with the highest rank always get prioritizes and thus Algorithm 3 is simulated.

Theorem 13**.**

There is an $\varepsilon$-tester in the CONGEST-model that on input $T$, where $T$ is a tree, the tester tests if the graph is $T$-free. The rounds complexity of the tester is $O\left(k^{k^{2}+1}\cdot\varepsilon^{-k}\right)$ where $k$ is the order of $T$.