Testing Graph Clusterability: Algorithms and Lower Bounds

The problem of sparsifying a graph or a hypergraph while approximately preserving its cut structure has been extensively studied and has many applications. In a seminal work, Benczúr and Karger (1996) showed that given any n-vertex undirected weighted graph G and a parameter ε ∈ (0,1), there is a near-linear time algorithm that outputs a weighted subgraph G' of G of size Õ(n/ε²) such that the weight of every cut in G is preserved to within a (1 ± ε)-factor in G'. The graph G' is referred to as a (1 ± ε)-approximate cut sparsifier of G. Subsequent recent work has obtained a similar result for the more general problem of hypergraph cut sparsifiers. However, all known sparsification algorithms require Ω(n + m) time where n denotes the number of vertices and m denotes the number of hyperedges in the hypergraph. Since m can be exponentially large in n, a natural question is if it is possible to create a hypergraph cut sparsifier in time polynomial in n, independent of the number of edges. We resolve this question in the affirmative, giving the first sublinear time algorithm for this problem, given appropriate query access to the hypergraph. Specifically, we design an algorithm that constructs a (1 ± ε)-approximate cut sparsifier of a hypergraph H(V,E) in polynomial time in n, independent of the number of hyperedges, when given access to the hypergraph using the following two queries: 1) given any cut (S, ̄S), return the size |δ_E(S)| (cut value queries); and 2) given any cut (S, ̄S), return a uniformly at random edge crossing the cut (cut edge sample queries). Our algorithm outputs a sparsifier with Õ(n/ε²) edges, which is essentially optimal. We then extend our results to show that cut value and cut edge sample queries can also be used to construct hypergraph spectral sparsifiers in poly(n) time, independent of the number of hyperedges. We complement the algorithmic results above by showing that any algorithm that has access to only one of the above two types of queries can not give a hypergraph cut sparsifier in time that is polynomial in n. Finally, we show that our algorithmic results also hold if we replace the cut edge sample queries with a pair neighbor sample query that for any pair of vertices, returns a random edge incident on them. In contrast, we show that having access only to cut value queries and queries that return a random edge incident on a given single vertex, is not sufficient.

In the k-junta testing problem, a tester has to efficiently decide whether a given function f: {0, 1}n → {0, 1} is a k-junta (i.e., depends on at most k of its input bits) or is ∊-far from any k-junta. Our main result is a quantum algorithm for this problem with query complexity and time complexity . This quadratically improves over the query complexity of the previous best quantum junta tester, due to Atıcı and Servedio. Our tester is based on a new quantum algorithm for a gapped version of the combinatorial group testing problem, with an up to quartic improvement over the query complexity of the best classical algorithm. For our upper bound on the time complexity we give a near-linear time implementation of a shallow variant of the quantum Fourier transform over the symmetric group, similar to the Schur-Weyl transform. We also prove a lower bound of Ω(k1/3) queries for junta-testing (for constant ∊).

We study vertex cut and flow sparsifiers that were recently introduced by Moitra (2009), and Leighton and Moitra (2010). We improve and generalize their results. We give a new polynomial-time algorithm for constructing O(log k/ log log k) cut and flow sparsifiers, matching the best known existential upper bound on the quality of a sparsifier, and improving the previous algorithmic upper bound of O(log2 k/ log log k). We show that flow sparsifiers can be obtained from linear operators approximating minimum metric extensions. We introduce the notion of (linear) metric extension operators, prove that they exist, and give an exact polynomialtime algorithm for finding optimal operators. We then establish a direct connection between flow and cut sparsifiers and Lipschitz extendability of maps in Banach spaces, a notion studied in functional analysis since 1930s. Using this connection, we obtain a lower bound of $$\Omega \left( {\sqrt {\log k/\log \log k} } \right)$$ for flow sparsifiers and a lower bound of $$\Omega \left( {\sqrt {\log k} /\log \log k} \right)$$ for cut sparsifiers. We show that if a certain open question posed by Ball in 1992 has a positive answer, then there exist $$\tilde O\left( {\sqrt {\log k} } \right)$$ cut sparsifiers. On the other hand, any lower bound on cut sparsifiers better than $$\tilde \Omega \left( {\sqrt {\log k} } \right)$$ would imply a negative answer to this question.

In this chapter we consider a Markov chain {ξ k , k ∈ Z +} having a finite state space but random transition probabilities. Of interest here is the asymptotic behavior of the chain and its transition probabilities as n → ∞ under the assumption that the transition probabilities of the Markov chain are close to those of a homogeneous Markov chain having nonrandom transition probabilities.

A novel technique for obtaining lower bounds for the time versus space complexity of certain functions in a general input oblivious sequential model of computation is developed. This is demonstrated by studying the intrinsic complexity of the following set equality problem SE(n,m): Given a sequence x1,x2,....,xn, y1,....,yn of 2n numbers of m bits each, decide whether the sets [x1,....,xn] and [y1,...,yn] coincide. We show that for any log log n ≤ m ≤1/2log n and any 1 ≤ s ≤ log n, any input oblivious sequential computation that solves SE(n,m) using 2m/s space, takes Ω(n ? s) time. This result is sharp for all admissible values of n,m,s and is the first known nontrivial time space tradeoff lower bound (for space = ω (log n) of a set recognition problem on such a general model of computation. Our method also supplies lower bounds on the length of arbitrary (not necessarily input oblivious) branching programs for several natural symmetric functions, improving results of Chandra, Furst and Lipton, of Pudlák and of Ajtai et. al. For example we show that for the majority - function any branching program of width w(n) has length ω(n · log w/n (n) · log w (n)), in particular for bounded width we get length ω (n log n) (independently of our work Babai et. al. [BPRS] have simultaneously proved this last result). Our lower bounds for branching programs imply lower bounds on the number of steps that are needed to pebble arbitrary computation graphs for the same computational problems. To establish our lower bounds we introduce the new concept of a meander that captures superconcentrator-type properties of sequences. We prove lower bounds on the length of meanders via a new Ramsey theoretic lemma that is of interest in its own right. This lemma has other applications, including a tight lower bound on the size of weak superconcentrators of depth 2 that strengthens the known lower bound of Pippenger [Pi]. A surprising new feature of these applications of Ramsey theory in lower bound arguments is the fact that no numbers are required to be unusually large and that several of the resulting superlinear lower bounds are in fact optimal.

Courcelle's famous theorem from 1990 states that any property of graphs definable in monadic second-order logic (MSO <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sub> ) can be decided in linear time on any class of graphs of bounded tree-width, or in other words, MSO <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sub> is fixed-parameter tractable in linear time on any such class of graphs. From a logical perspective, Courcelle's theorem establishes a sufficient condition, or an upper bound, for tractability of MSO <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sub> -model checking. Whereas such upper bounds on the complexity of logics have received significant attention in the literature, almost nothing is known about corresponding lower bounds. In this paper we establish a strong lower bound for the complexity of monadic second-order logic. In particular, we show that if C is any class of graphs which is closed under taking sub-graphs and whose tree-width is not bounded by a poly-logarithmic function (in fact, log <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">c</sup> n for some small c suffices) then MSO <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sub> -model checking is intractable on C (under a suitable assumption from complexity theory).

Previous chapter Next chapter Full AccessProceedings Proceedings of the 2022 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA)Polygon Placement Revisited: (Degree of Freedom + 1)-SUM Hardness and an Improvement via Offline Dynamic Rectangle UnionMarvin Künnemann and André NusserMarvin Künnemann and André Nusserpp.3181 - 3201Chapter DOI:https://doi.org/10.1137/1.9781611977073.124PDFBibTexSections ToolsAdd to favoritesExport CitationTrack CitationsEmail SectionsAboutAbstract We revisit a classical problem in computational geometry: Determine the largest copy of a simple polygon P that can be placed into the simple polygon Q. Despite significant effort studying a number of settings, known algorithms require high polynomial running times, even for the interesting case when either P or Q have constant size. (Barequet and Har-Peled, 2001) give a conditional lower bound of n2–o(1) under the 3SUM conjecture when P and Q are (convex) polygons with Θ(n) vertices each. This leaves open whether we can establish (1) hardness beyond quadratic time and (2) any superlinear bound for constant-sized P or Q. In this paper, we affirmatively answer these questions under the higher-order kSUM conjecture, proving natural hardness results that increase with each degree of freedom (scaling, x-translation, y-translation, rotation): (scaling, x-translation:) Finding the largest copy of P that can be x-translated into Q requires time n2–o(1) under the 3SUM conjecture, even for orthogonal (rectilinear) polygons P, Q with O(1) and n vertices, respectively. (scaling, x-translation, y-translation:) Finding the largest copy of P that can be arbitrarily translatedinto Q requires time n2–o(1) under the 4SUM conjecture, even for orthogonal polygons P, Q with O(1) and n vertices, respectively. This establishes the same lower bound under the assumption that Subset Sum cannot be solved in time O((2–∊)n/2) for any ∊ > 0. The above lower bounds are almost tight when one of the polygons is of constant size: Using an offline dynamic algorithm for maintaining the area of a union of rectangles due to Overmars and Yap, we obtain an -time algorithm for orthogonal polygons P, Q with p and q vertices, respectively. This matches the lower bounds up to an n1/2+o(1)-factor when P, Q have O(1) and n vertices. (scaling, x-translation, y-translation, rotation:) Finally, finding the largest copy of P that can be arbitrarily rotated and translated into Q requires time n3–o(1) under the 5SUM conjecture. As in our reductions, each degree of freedom determines one summand in a kSUM instance, these lower bounds appear likely to be best possible under kSUM. We are not aware of any other such natural (degree of freedom + 1)-SUM hardness for a geometric optimization problem. Finally, we prove an additional tight OV hardness of the translations-only case. Previous chapter Next chapter RelatedDetails Published:2022eISBN:978-1-61197-707-3 https://doi.org/10.1137/1.9781611977073Book Series Name:ProceedingsBook Code:PRDA22Book Pages:xvii + 3771

Motivated by the increasing need for fast distributed processing of large-scale graphs such as the Web graph and various social networks, we study a number of fundamental graph problems in the message-passing model, where we have k machines that jointly perform computation on an arbitrary n-node (typically, n > k) input graph. The graph is assumed to be randomly partitioned among the k ≥ 2 machines (a common implementation in many real world systems). The communication is point-to-point, and the goal is to minimize the time complexity i.e., the number of communication rounds, of solving various fundamental graph problems.We present lower bounds that quantify the fundamental time limitations of distributively solving graph problems. We first show a lower bound of Ω(n/k) rounds for computing a spanning tree (ST) of the input graph. This result also implies the same bound for other fundamental problems such as computing a minimum spanning tree (MST), breadth-first tree (BFS), and shortest paths tree (SPT). We also show an Ω(n/k2) lower bound for connectivity ST verification and other related problems. Our lower bounds develop and use new bounds in random-partition communication complexity.To complement our lower bounds, we also give algorithms for various fundamental graph problems, e.g., PageRank, MST, connectivity, ST verification, shortest paths, cuts, spanners, covering problems, densest subgraph, subgraph isomorphism, finding triangles, etc. We show that problems such as PageRank, MST, connectivity, and graph covering can be solved in O(n/k) time (the notation O hides polylog(n) factors and an additive polylog(n) term); this shows that one can achieve almost linear (in k) speedup, whereas for shortest paths, we present algorithms that run in O(n/Ok) time (for (1 + e)-factor approximation) and in O(n/k) time (for O(log n)-factor approximation) respectively.Our results are a step towards understanding the complexity of distributively solving large-scale graph problems.

Consider an n-point metric space M = (V,δ), and a transmission range assignment r: V → ℝ + that maps each point v ∈ V to the disk of radius r(v) around it. The symmetric disk graph (henceforth, SDG) that corresponds to M and r is the undirected graph over V whose edge set includes an edge (u,v) if both r(u) and r(v) are no smaller than δ(u,v). SDGs are often used to model wireless communication networks.Abu-Affash, Aschner, Carmi and Katz (SWAT 2010, [1]) showed that for any n-point 2-dimensional Euclidean space M, the weight of the MST of every connected SDG for M is O(logn) ·w(MST(M)), and that this bound is tight. However, the upper bound proof of [1] relies heavily on basic geometric properties of constant-dimensional Euclidean spaces, and does not extend to Euclidean spaces of super-constant dimension. A natural question that arises is whether this surprising upper bound of [1] can be generalized for wider families of metric spaces, such as high-dimensional Euclidean spaces.In this paper we generalize the upper bound of Abu-Affash et al. [1] for Euclidean spaces of any dimension. Furthermore, our upper bound extends to arbitrary metric spaces and, in particular, it applies to any of the normed spaces ℓ p . Specifically, we demonstrate that for any n-point metric space M, the weight of the MST of every connected SDG for M is O(logn) ·w(MST(M)).KeywordsSpan TreeTransmission RangeMinimum Span TreeHamiltonian PathUnit Disk GraphThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Random polygon Generation from a given set of points is very important for different applications. A heuristic termed as “GRP_AS” has been proposed here to generate a random simple polygon from a given set of `n' points in 2-Dimensional plane. The “2-Opt Move” heuristic with time complexity O(n <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">4</sup> ) is the best known among the existing heuristics to generate a simple polygon. We recently designed another heuristic “GRP_CH” for the same problem with time complexity O(n <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">3</sup> ) which was shown to be better than that of “2-Opt Move” heuristic in terms of random behaviour and time complexity. In this work, our main objective is to design an algorithm with reduced time complexity. The proposed heuristic, “GRP_AS” is based on the principle of random selection of a line segment and angular sorting of the point set. This “GRP_AS” heuristic takes O(nlogn) time which is less than that of “2-Opt Move” heuristic as well as “GRP_CH” heuristic. The lower bound and upper bound on the number of polygons generated in “GRP_AS” heuristic has been computed.

M AX -C UT , E DGE D OMINATING S ET , G RAPH C OLORING , and H AMILTONIAN C YCLE on graphs of bounded clique-width have received significant attention as they can be formulated in MSO 2 (and, therefore, have linear-time algorithms on bounded treewidth graphs by the celebrated Courcelle’s theorem), but cannot be formulated in MSO 1 (which would have yielded linear-time algorithms on bounded clique-width graphs by a well-known theorem of Courcelle, Makowsky, and Rotics). Each of these problems can be solved in time g ( k ) n f ( k ) on graphs of clique-width k . Fomin et al. (2010) showed that the running times cannot be improved to g ( k ) n O (1) assuming W[1]≠FPT. However, this does not rule out non-trivial improvements to the exponent f ( k ) in the running times. In a follow-up paper, Fomin et al. (2014) improved the running times for E DGE D OMINATING S ET and M AX -C UT to n O ( k ) , and proved that these problems cannot be solved in time g ( k ) n o ( k ) unless ETH fails. Thus, prior to this work, E DGE D OMINATING S ET and M AX -C UT were known to have tight n Θ ( k ) algorithmic upper and lower bounds. In this article, we provide lower bounds for H AMILTONIAN C YCLE and G RAPH C OLORING . For H AMILTONIAN C YCLE , our lower bound g ( k ) n o ( k ) matches asymptotically the recent upper bound n O ( k ) due to Bergougnoux, Kanté, and Kwon (2017). As opposed to the asymptotically tight n Θ( k ) bounds for E DGE D OMINATING S ET , M AX -C UT , and H AMILTONIAN C YCLE , the G RAPH C OLORING problem has an upper bound of n O (2 k ) and a lower bound of merely n o (√ [4] k ) (implicit from the W[1]-hardness proof). In this article, we close the gap for G RAPH C OLORING by proving a lower bound of n 2 o ( k ) . This shows that G RAPH C OLORING behaves qualitatively different from the other three problems. To the best of our knowledge, G RAPH C OLORING is the first natural problem known to require exponential dependence on the parameter in the exponent of n .

Let q 1 &gt; q 2 &gt; q 3 q_1&gt;q_2&gt;q_3 be odd primes and N = q 1 q 2 q 3 N=q_1q_2q_3 . Put \[ d = gcd ( q 1 − 1 , q 2 − 1 , q 3 − 1 ) and h i = q i − 1 d , i = 1 , 2 , 3. d=\gcd (q_1-1,q_2-1,q_3-1) \text { and } h_i=\tfrac {q_i-1}d, \;i=1,2,3. \] Then we call d d the kernel , the triple ( h 1 , h 2 , h 3 ) (h_1,h_2,h_3) the signature , and H = h 1 h 2 h 3 H=h_1h_2h_3 the height of N N , respectively. We call N N a C 3 C_3 -number if it is a Carmichael number with each prime factor q i ≡ 3 mod 4 q_i\equiv 3\mod 4 . If N N is a C 3 C_3 -number and a strong pseudoprime to the t t bases b i b_i for 1 ≤ i ≤ t 1\leq i\leq t , we call N N a C 3 C_3 -spsp ( b 1 , b 2 , … , b t ) (b_1, b_2,\dots ,b_t) . Since C 3 C_3 -numbers have probability of error 1 / 4 1/4 (the upper bound of that for the Rabin-Miller test), they often serve as the exact values or upper bounds of ψ m \psi _m (the smallest strong pseudoprime to all the first m m prime bases). If we know the exact value of ψ m \psi _m , we will have, for integers n &gt; ψ m n&gt;\psi _m , a deterministic efficient primality testing algorithm which is easy to implement. In this paper, we first describe an algorithm for finding C 3 C_3 -spsp(2)’s, to a given limit, with heights bounded. There are in total 21978 21978 C 3 C_3 -spsp ( 2 ) (2) ’s &gt; 10 24 &gt;10^{24} with heights &gt; 10 9 &gt;10^9 . We then give an overview of the 21978 C 3 C_3 - spsp(2)’s and tabulate 54 54 of them, which are C 3 C_3 -spsp’s to the first 8 8 prime bases up to 19 19 ; three numbers are spsp’s to the first 11 prime bases up to 31. No C 3 C_3 -spsp’s &gt; 10 24 &gt;10^{24} to the first 12 12 prime bases with heights &gt; 10 9 &gt;10^9 were found. We conjecture that there exist no C 3 C_3 -spsp’s &gt; 10 24 &gt;10^{24} to the first 12 12 prime bases with heights ≥ 10 9 \geq 10^9 and so that ψ 12 a m p ; = 3186 65857 83403 11511 67461 (24 digits) a m p ; = 399165290221 ⋅ 798330580441 , \begin{equation*} \begin {split} \psi _{12}&amp;= 3186\; 65857\; 83403\; 11511\; 67461\; \text {(24 digits)} \\ &amp;=399165290221\cdot 798330580441, \end{split}\end{equation*} which was found by the author in an earlier paper. We give reasons to support the conjecture. The main idea of our method for finding those 21978 21978 C 3 C_3 -spsp ( 2 ) (2) ’s is that we loop on candidates of signatures and kernels with heights bounded, subject those candidates N = q 1 q 2 q 3 N=q_1q_2q_3 of C 3 C_3 -spsp ( 2 ) (2) ’s and their prime factors q 1 , q 2 , q 3 q_1,q_2,q_3 to Miller’s tests, and obtain the desired numbers. At last we speed our algorithm for finding larger C 3 C_3 -spsp’s, say up to 10 50 10^{50} , with a given signature to more prime bases. Comparisons of effectiveness with Arnault’s and our previous methods for finding C 3 C_3 -strong pseudoprimes to the first several prime bases are given.

This paper initiates the study of algorithms (minimizing cache misses) from the perspective of fine-grained complexity (conditional polynomial lower bounds). Specifically, we aim to answer why sparse graph problems are so hard, and why the Longest Common Subsequence problem gets a savings of a factor of the size of cache times the length of a cache line, but no more. We take the reductions and techniques from complexity and fine-grained complexity and apply them to the model to generate new (conditional) lower bounds as well as new faster algorithms. We also prove the existence of a hierarchy for the model, which motivates the fine-grained reductions. - Using fine-grained reductions, we give an algorithm for distinguishing 2 vs. 3 diameter and radius that runs in O(|E|^2/(MB)) cache misses, which for sparse graphs improves over the previous O(|V|^2/B) running time. - We give new reductions from radius and diameter to Wiener index and median. These reductions are new in both the RAM and models. - We show meaningful reductions between problems that have linear-time solutions in the RAM model. The reductions use low complexity (typically O(n/B)), and thus help to finely capture between I/O linear time O(n/B) and RAM linear O(n). - We generate new assumptions based on the difficulty of improving sparse graph problem running times in the model. We create conjectures that the current best known algorithms for Single Source Shortest Paths (SSSP), diameter, and radius are optimal. - From these I/O-model assumptions, we show that many of the known reductions in the word-RAM model can naturally extend to hold in the model as well (e.g., a lower bound on the complexity of Longest Common Subsequence that matches the best known running time). - We prove an analog of the Time Hierarchy Theorem in the model, further motivating the study of fine-grained algorithmic differences.

This article initiates the study of testing properties of directed graphs. In particular, the article considers the most basic property of directed graphs--acyclicity. Because the choice of representation affects the choice of algorithm, the two main representations of graphs are studied. For the adjacency-matrix representation, most appropriate for dense graphs, a testing algorithm is developed that requires query and time complexity of O(1/e2), where e is a distance parameter independent of the size of the graph. The algorithm, which can probe the adjacency matrix of the graph, accepts every graph that is acyclic, and rejects, with probability at least 2/3, every graph whose adjacency matrix should be modified in at least e fraction of its entries so that it becomes acyclic. For the incidence list representation, most appropriate for sparse graphs, an Ω(|V|1/3) lower bound is proved on the number of queries and the time required for testing, where V is the set of vertices in the graph. Along with acyclicity, this article considers the property of strong connectivity. Contrasting upper and lower bounds are proved for the incidence list representation. In particular, if the testing algorithm can query on both incoming and outgoing edges at each vertex, then it is possible to test strong connectivity in O(1/e) time and query complexity. On the other hand, if the testing algorithm only has access to outgoing edges, then Ω(√N) queries are required to test for strong connectivity.

Two strongly NP-hard problems of clustering a finite set of points in Euclidean space are considered. In the first problem, given an input set, we need to find a cluster (i.e., a subset) of given size that minimizes the sum of the squared distances between the elements of this cluster and its centroid (geometric center). Every point outside this cluster is considered a singleton cluster. In the second problem, we need to partition a finite set into two clusters minimizing the sum, over both clusters, of weighted intracluster sums of the squared distances between the elements of the clusters and their centers. The center of one of the clusters is unknown and is determined as its centroid, while the center of the other cluster is set at some point of space (without loss of generality, at the origin). The weighting factors for both intracluster sums are the given cluster sizes. Parameterized randomized algorithms are presented for both problems. For given upper bounds on the relative error and the failure probability, the parameter value is defined for which both algorithms find approximation solutions in polynomial time. This running time is linear in the space dimension and the size of the input set. The conditions are found under which the algorithms are asymptotically exact and their time complexity is linear in the space dimension and quadratic in the input set size.