Subquadratic Time Research Articles

Solving Linear Programs in the Current Matrix Multiplication Time

This article shows how to solve linear programs of the form min Ax = b , x ≥ 0 c ⊤ x with n variables in time O * (( n ω + n 2.5−α/2 + n 2+1/6 ) log ( n /δ)), where ω is the exponent of matrix multiplication, α is the dual exponent of matrix multiplication, and δ is the relative accuracy. For the current value of ω δ 2.37 and α δ 0.31, our algorithm takes O * ( n ω log ( n /δ)) time. When ω = 2, our algorithm takes O * ( n 2+1/6 log ( n /δ)) time. Our algorithm utilizes several new concepts that we believe may be of independent interest: • We define a stochastic central path method. • We show how to maintain a projection matrix √ W A ⊤ ( AWA ⊤ ) −1 A √ W in sub-quadratic time under \ell 2 multiplicative changes in the diagonal matrix W .

Fine-grained Complexity Analysis of Two Classic TSP Variants

We analyze two classic variants of the T RAVELING S ALESMAN P ROBLEM ( TSP ) using the toolkit of fine-grained complexity. Our first set of results is motivated by the B ITONIC TSP problem: given a set of n points in the plane, compute a shortest tour consisting of two monotone chains. It is a classic dynamic-programming exercise to solve this problem in O ( n 2 ) time. While the near-quadratic dependency of similar dynamic programs for L ONGEST C OMMON S UBSEQUENCE and D ISCRETE F réchet D istance has recently been proven to be essentially optimal under the Strong Exponential Time Hypothesis, we show that bitonic tours can be found in subquadratic time. More precisely, we present an algorithm that solves bitonic TSP in O ( n log 2 n ) time and its bottleneck version in O ( n log 3 n ) time. In the more general pyramidal TSP problem, the points to be visited are labeled 1,… , n and the sequence of labels in the solution is required to have at most one local maximum. Our algorithms for the bitonic (bottleneck) TSP problem also work for the pyramidal TSP problem in the plane. Our second set of results concerns the popular k - OPT heuristic for TSP in the graph setting. More precisely, we study the k - OPT decision problem, which asks whether a given tour can be improved by a k - OPT move that replaces k edges in the tour by k new edges. A simple algorithm solves k - OPT in O ( n k ) time for fixed k . For 2- OPT , this is easily seen to be optimal. For k =3, we prove that an algorithm with a runtime of the form Õ( n 3−ɛ ) exists if and only if A LL -P AIRS S HORTEST P ATHS in weighted digraphs has such an algorithm. For general k - OPT , it is known that a runtime of f ( k ) · n o ( k / log k ) would contradict the Exponential Time Hypothesis. The results for k =2,3 may suggest that the actual time complexity of k - OPT is Θ ( n k ). We show that this is not the case, by presenting an algorithm that finds the best k -move in O ( n ⌊ 2 k /3 ⌋+1 ) time for fixed k ≥ 3. This implies that 4- OPT can be solved in O ( n 3 ) time, matching the best-known algorithm for 3- OPT . Finally, we show how to beat the quadratic barrier for k =2 in two important settings, namely, for points in the plane and when we want to solve 2- OPT repeatedly.

Approximating Edit Distance Within Constant Factor in Truly Sub-quadratic Time

Edit distance is a measure of similarity of two strings based on the minimum number of character insertions, deletions, and substitutions required to transform one string into the other. The edit distance can be computed exactly using a dynamic programming algorithm that runs in quadratic time. Andoni, Krauthgamer, and Onak (2010) gave a nearly linear time algorithm that approximates edit distance within approximation factor poly(log n ). In this article, we provide an algorithm with running time Õ( n 2−2/7 ) that approximates the edit distance within a constant factor.

A story of diameter, radius, and (almost) Helly property

AbstractWe present new algorithmic results for the class of Helly graphs, that is, for the discrete analogues of hyperconvex metric spaces. Specifically, an undirected unweighted graph is Helly if every family of pairwise intersecting balls has a nonempty common intersection. It is known that every graph isometrically embeds into a Helly graph that makes of the latter an important class of graphs in metric graph theory. We study diameter and radius computations within the Helly graphs, and related graph classes. This is in part motivated by a conjecture on the fine‐grained complexity of these two distance problems within the graph classes of bounded fractional Helly number—that contain as particular cases the proper minor‐closed graph classes and the bounded clique‐width graphs. Note that under plausible complexity assumptions, neither the diameter nor the radius can be computed in truly subquadratic time on general graphs. In contrast to these negative results, we first present algorithms which given an n‐vertex m‐edge Helly graph G as input, compute with high probability (w.h.p.) its radius and its diameter in time (i.e., subquadratic in n + m). Our algorithms are based on the Helly property and on the unimodality of the eccentricity function in Helly graphs: every vertex of locally minimum eccentricity is a central vertex. Then, we improve our results for the C4‐free Helly graphs, that are exactly the Helly graphs whose balls are convex. For this subclass, we present linear‐time algorithms for computing the eccentricity of all vertices. Doing so, we generalize previous results on strongly chordal graphs to a much larger subclass, that includes, among others, all the bridged Helly graphs and the hereditary Helly graphs. Lastly, we derive approximate versions of our results for the class of chordal graphs: with the latter satisfying an almost‐Helly‐type property, and a stronger (induced‐path) convexity property than the C4‐free Helly graphs. For the chordal graphs, we can compute in quasi linear time the eccentricity of all vertices with an additive one‐sided error of at most one, which is best possible under the strong exponential‐time hypothesis. This answers an open question of Dragan. In fact, we obtain this last result as a byproduct from a more general reduction: from diameter computation on chordal graphs to the Disjoint Sets problem. Roughly, it implies that the split graphs are the only hard instances for diameter computation on chordal graphs. We also get from our reduction that on any subclass of chordal graphs with constant VC‐dimension (and so, for undirected path graphs), the diameter can be computed in truly subquadratic time.

Smallest k-Enclosing Rectangle Revisited

Given a set of n points in the plane, and a parameter $$k$$ , we consider the problem of computing the minimum (perimeter or area) axis-aligned rectangle enclosing $$k$$ points. We present the first near quadratic time algorithm for this problem, improving over the previous near- $$O(n^{5/2})$$ -time algorithm by Kaplan et al. (25th European Symposium on Algorithms. Leibniz Int Proc Inform, vol. 87, # 52. Leibniz-Zent Inform, Wadern, 2017). We provide an almost matching conditional lower bound, under the assumption that $$(\min ,+)$$ -convolution cannot be solved in truly subquadratic time. Furthermore, we present a new reduction (for both perimeter and area) that can make the time bound sensitive to $$k$$ , giving near $$O(nk)$$ time. We also present a near linear time $$(1+\varepsilon )$$ -approximation algorithm to the minimum area of the optimal rectangle containing $$k$$ points. In addition, we study related problems including the 3-sided, arbitrarily oriented, weighted, and subset sum versions of the problem.

Explicit Correlation Amplifiers for Finding Outlier Correlations in Deterministic Subquadratic Time

We derandomize Valiant’s (J ACM 62, Article 13, 2015) subquadratic-time algorithm for finding outlier correlations in binary data. This demonstrates that it is possible to perform a deterministic subquadratic-time similarity join of high dimensionality. Our derandomized algorithm gives deterministic subquadratic scaling essentially for the same parameter range as Valiant’s randomized algorithm, but the precise constants we save over quadratic scaling are more modest. Our main technical tool for derandomization is an explicit family of correlation amplifiers built via a family of zigzag-product expanders by Reingold et al. (Ann Math 155(1):157–187, 2002). We say that a function f:{-1,1}^drightarrow {-1,1}^D is a correlation amplifier with threshold 0le tau le 1, error gamma ge 1, and strength p an even positive integer if for all pairs of vectors x,yin {-1,1}^d it holds that (i) |langle x,yrangle |<tau d implies |langle f(x),f(y)rangle |le (tau gamma )^pD; and (ii) |langle x,yrangle |ge tau d implies left (frac{langle x,yrangle }{gamma d}right )^pD le langle f(x),f(y)rangle le left (frac{gamma langle x,yrangle }{d}right )^pD.

On Closest Pair in Euclidean Metric: Monochromatic is as Hard as Bichromatic

Given a set of n points in ℝd, the (monochromatic) Closest Pair problem asks to find a pair of distinct points in the set that are closest in the lp-metric. Closest Pair is a fundamental problem in Computational Geometry and understanding its fine-grained complexity in the Euclidean metric when d = ω(log n) was raised as an open question in recent works (Abboud-Rubinstein-Williams [6], Williams [48], David-Karthik-Laekhanukit [17]). In this paper, we show that for every p ∈ ℝ≥1 ∪ {0}, under the Strong Exponential Time Hypothesis (SETH), for every e > 0, the following holds: In particular, our first result is shown by establishing the computational equivalence of the bichromatic Closest Pair problem and the (monochromatic) Closest Pair problem (up to ne factor in the running time) for $$d = {\left({\log n} \right)^{{\Omega _\varepsilon}\left(1 \right)}}$$ dimensions. Additionally, under SETH, we rule out nearly-polynomial factor approximation algorithms running in subquadratic time for the (monochromatic) Maximum Inner Product problem where we are given a set of n points in no(1)-dimensional Euclidean space and are required to find a pair of distinct points in the set that maximize the inner product. At the heart of all our proofs is the construction of a dense bipartite graph with low contact dimension, i.e., we construct a balanced bipartite graph on n vertices with n2−e edges whose vertices can be realized as points in a $${\left({\log n} \right)^{{\Omega _\varepsilon}\left(1 \right)}}$$ -dimensional Euclidean space such that every pair of vertices which have an edge in the graph are at distance exactly 1 and every other pair of vertices are at distance greater than 1. This graph construction is inspired by the construction of locally dense codes introduced by Dumer-Micciancio-Sudan [18].

Learning directed acyclic graph SPNs in sub-quadratic time

In this paper, we present Prometheus, a graph partitioning based algorithm that creates multiple variable decompositions efficiently for learning Sum-Product Network structures across both continuous and discrete domains. Prometheus proceeds by creating multiple candidate decompositions that are represented compactly with an acyclic directed graph in which common parts of different decompositions are shared. It eliminates the correlation threshold hyperparameter often used in other structure learning techniques, allowing Prometheus to learn structures that are robust in low data regimes. Prometheus outperforms other structure learning techniques in 30 discrete and continuous domains. We also extend Prometheus to exploit sparsity in correlations between features in order to obtain an efficient sub-quadratic algorithm (w.r.t. the number of features) that scales better to high dimensional datasets.

On The Hardness of Approximate and Exact (Bichromatic) Maximum Inner Product

In this paper we study the (Bichromatic) Maximum Inner Product Problem (Max-IP), in which we are given sets A and B of vectors, and the goal is to find a ∈ A and b ∈ B maximizing inner product a · b. Max-IP is very basic and serves as the base problem in the recent breakthrough of [Abboud et al., FOCS 2017] on hardness of approximation for polynomial-time problems. It is also used (implicitly) in the argument for hardness of exact e2-Furthest Pair (and other important problems in computational geometry) in poly-log-log dimensions in [Williams, SODA 2018]. We have three main results regarding this problem.• Characterization of Multiplicative Approximation. First, we study the best multiplicative approximation ratio for Boolean Max-IP in sub-quadratic time. We show that, for Max-IP with two sets of n vectors from {0, 1}d, there is an n2−ω(1) time (d/logn)ω(1) - multiplicative-approximating algorithm, and we show this is conditionally optimal, as such a (d/logn)o(1)-approximating algorithm would refute SETH. Similar characterization is also achieved for additive approximation for Max-IP.• 2O(log* n)-dimensional Hardness for Exact Max-IP Over The Integers. Second, we revisit the hardness of solving Max-IP exactly for vectors with integer entries. We show that, under SETH, for Max-IP with sets of n vectors from Zd for some d = 2O(log* n), every exact algorithm requires n2−o(1) time. With the reduction from [Williams, SODA 2018], it follows that e2-Furthest Pair and Bichromatic e2-Closest Pair in 2O(log* n) dimensions require n2−o(1) time.• Connection with NP · UPP Communication Protocols. Last, We establish a connection between conditional lower bounds for exact Max-IP with integer entries and NP · UPP communication protocols for Set-Disjointness, parallel to the connection between conditional lower bounds for approximating Max-IP and MA communication protocols for Set-Disjointness.The lower bound in our first result is a direct corollary of the new MA protocol for Set-Disjointness introduced in [Rubinstein, STOC 2018], and our algorithms utilize the polynomial method and simple random sampling. Our second result follows from a new dimensionality self reduction from the Orthogonal Vectors problem for n vectors from {0, 1}d to n vectors from Ze where e = 2O(log* d), dramatically improving the previous reduction in [Williams, SODA 2018]. The key technical ingredient is a recursive application of Chinese Remainder Theorem.As a side product, we obtain an MA communication protocol for Set-Disjointness with complexity [EQUATION], slightly improving the [EQUATION] log n) bound [Aaronson and Wigderson, TOCT 2009], and approaching the [EQUATION] lower bound [Klauck, CCC 2003].Moreover, we show that (under SETH) one can apply the [EQUATION] BQP communication protocol for Set-Disjointness to prove near-optimal hardness for approximation to Max-IP with vectors in {− 1, 1}d. This answers a question from [Abboud et al., FOCS 2017] in the affirmative.

Optimal Dislocation with Persistent Errors in Subquadratic Time

We study the problem of sorting N elements in the presence of persistent errors in comparisons: In this classical model, each comparison between two elements is wrong independently with some probability up to p, but repeating the same comparison gives always the same result. In this model, it is impossible to reliably compute a perfectly sorted permutation of the input elements. Rather, the quality of a sorting algorithm is often evaluated w.r.t. the maximum dislocation of the sequences it computes, namely, the maximum absolute difference between the position of an element in the returned sequence and the position of the same element in the perfectly sorted sequence. The best known algorithms for this problem have running time O(N2) and achieve, w.h.p., an optimal maximum dislocation of $O(\log N)$ for constant error probability p. Note that no algorithm can achieve maximum dislocation $o(\log N)$ w.h.p., regardless of its running time. In this work we present the first subquadratic time algorithm with optimal maximum dislocation. Our algorithm runs in $\widetilde {O}(N^{3/2})$ time and it guarantees $O(\log N)$ maximum dislocation with high probability for any p ≤ 1/16.

A Contrast Metric for Fraud Detection in Rich Graphs

How can we detect fraud in a big graph with rich properties, as online fraudsters invest more resources, including purchasing large pools of fake user accounts and dedicated IPs, to hide their fraudulent attacks? To achieve robustness, existing approaches detected dense sub-graphs as suspicious patterns in an unsupervised way, such as average degree maximization. However, such approaches suffer from the bias of including more nodes than necessary, resulting in lower accuracy and increased need for manual verification. Therefore, we propose HoloScope, which introduces a novel metric “contrast suspiciousness” integrating information from graph topology and spikes to more accurately detect fraudulent users and objects. Contrast suspiciousness dynamically emphasizes the contrasting patterns between fraudsters and normal users, making HoloScope capable of distinguishing the synchronized and strange behaviors of fraudsters by means of topology, bursts and drops, and rating scores. In addition, we provide theoretical bounds for how much this method increases the time cost needed for fraudsters to conduct adversarial attacks. Moreover, HoloScope has a concise framework and sub-quadratic time complexity, making the algorithm reproducible and scalable. In extensive experiments, HoloScope achieved significant accuracy improvements on real data with injected labels and true labels, when compared with state-of-the-art fraud detection methods.

Accelerated tower arithmetic

Nowadays, asymptotically fast algorithms are widely used in computer algebra for computations in towers of algebraic field extensions of small height. Yet it is still unknown how to reach softly linear time for products and inversions in towers of arbitrary height. In this paper we design the first algorithm for general ground fields with a complexity exponent that can be made arbitrarily close to one from the asymptotic point of view. We deduce new faster algorithms for changes of tower representations, including the computation of primitive element representations in subquadratic time.

Minimum Perimeter-Sum Partitions in the Plane

Let $P$ be a set of $n$ points in the plane. We consider the problem of partitioning $P$ into two subsets $P_1$ and $P_2$ such that the sum of the perimeters of $\text{CH}(P_1)$ and $\text{CH}(P_2)$ is minimized, where $\text{CH}(P_i)$ denotes the convex hull of $P_i$. The problem was first studied by Mitchell and Wynters in 1991 who gave an $O(n^2)$ time algorithm. Despite considerable progress on related problems, no subquadratic time algorithm for this problem was found so far. We present an exact algorithm solving the problem in $O(n \log^2 n)$ time and a $(1+\varepsilon)$-approximation algorithm running in $O(n + 1/\varepsilon^2\cdot\log^2(1/\varepsilon))$ time.

Subquadratic Algorithms for Algebraic 3SUM

The 3SUM problem asks if an input n-set of real numbers contains a triple whose sum is zero. We qualify such a triple of degenerate because the probability of finding one in a random input is zero. We consider the 3POL problem, an algebraic generalization of 3SUM where we replace the sum function by a constant-degree polynomial in three variables. The motivations are threefold. Raz et al. gave an $$O(n^{11/6})$$ upper bound on the number of degenerate triples for the 3POL problem. We give algorithms for the corresponding problem of counting them. Gronlund and Pettie designed subquadratic algorithms for 3SUM. We prove that 3POL admits bounded-degree algebraic decision trees of depth $$O(n^{12/7+\varepsilon })$$ , and we prove that 3POL can be solved in $$O(n^2 {(\log \log n)}^{3/2} / {(\log n)}^{1/2})$$ time in the real-RAM model, generalizing their results. Finally, we shed light on the General Position Testing (GPT) problem: “Given n points in the plane, do three of them lie on a line?”, a key problem in computational geometry: we show how to solve GPT in subquadratic time when the input points lie on a small number of constant-degree polynomial curves. Many other geometric degeneracy testing problems reduce to 3POL.

Tight Conditional Lower Bounds for Longest Common Increasing Subsequence

We consider the canonical generalization of the well-studied Longest Increasing Subsequence problem to multiple sequences, called k-LCIS: Given k integer sequences X_1,dots ,X_k of length at most n, the task is to determine the length of the longest common subsequence of X_1,dots ,X_k that is also strictly increasing. Especially for the case of k=2 (called LCIS for short), several algorithms have been proposed that require quadratic time in the worst case. Assuming the Strong Exponential Time Hypothesis (SETH), we prove a tight lower bound, specifically, that no algorithm solves LCIS in (strongly) subquadratic time. Interestingly, the proof makes no use of normalization tricks common to hardness proofs for similar problems such as Longest Common Subsequence. We further strengthen this lower bound (1) to rule out {mathcal {O}}left( (nL)^{1-varepsilon }right) time algorithms for LCIS, where L denotes the solution size, (2) to rule out {mathcal {O}}left( n^{k-varepsilon }right) time algorithms for k-LCIS, and (3) to follow already from weaker variants of SETH. We obtain the same conditional lower bounds for the related Longest Common Weakly Increasing Subsequence problem.

Edit Distance Cannot Be Computed in Strongly Subquadratic Time (Unless SETH is False)

The edit distance (a.k.a. the Levenshtein distance) between two strings is defined as the minimum number of insertions, deletions, or substitutions of symbols needed to transform one string into an...

Subquadratic Time Algorithm to Find the Connected Components of Circle Graphs

Subquadratic Time Algorithm to Find the Connected Components of Circle Graphs

It’s All a Matter of Degree

We optimize multiway equijoins on relational tables using degree information. We give a new bound that uses degree information to more tightly bound the maximum output size of a query. On real data, our bound on the number of triangles in a social network can be up to 95 times tighter than existing worst case bounds. We show that using only a constant amount of degree information, we are able to obtain join algorithms with a running time that has a smaller exponent than existing algorithms–for any database instance. We also show that this degree information can be obtained in nearly linear time, which yields asymptotically faster algorithms in the serial setting and lower communication cost algorithms in the MapReduce setting. In the serial setting, the data complexity of join processing can be expressed as a function O(IN x + OUT) in terms of input size IN and output size OUT in which x depends on the query. An upper bound for x is given by the fractional hypertreewidth. We are interested in situations in which we can get algorithms for which x is strictly smaller than the fractional hypertreewidth. We say that a join can be processed in subquadratic time if x < 2. Building on the AYZ algorithm for processing cycle joins in quadratic time, for a restricted class of joins which we call 1-series-parallel graphs, we obtain a complete decision procedure for identifying subquadratic solvability (subject to the 3-SUM problem requiring quadratic time). Our 3-SUM based quadratic lower bound is tight, making it the only known tight bound for joins that does not require any assumption about the matrix multiplication exponent ω. We also give a MapReduce algorithm that meets our improved communication bound and handles essentially optimal parallelism.

Analytic results on the polymerisation random graph model

The step-growth polymerisation of a mixture of arbitrary-functional monomers is viewed as a time-continuos random graph process with degree bounds that are not necessarily the same for different vertices. The sequence of degree bounds acts as the only input parameter of the model. This parameter entirely defines the timing of the phase transition. Moreover, the size distribution of connected components features a rich temporal dynamics that includes: switching between exponential and algebraic asymptotes and acquiring oscillations. The results regarding the phase transition and the expected size of a connected component are obtained in a closed form. An exact expression for the size distribution is resolved up to the convolution power and is computable in subquadratic time. The theoretical results are illustrated on a few special cases, including a comparison with Monte Carlo simulations.

ESPRIT-Forest: Parallel clustering of massive amplicon sequence data in subquadratic time.

The rapid development of sequencing technology has led to an explosive accumulation of genomic sequence data. Clustering is often the first step to perform in sequence analysis, and hierarchical clustering is one of the most commonly used approaches for this purpose. However, it is currently computationally expensive to perform hierarchical clustering of extremely large sequence datasets due to its quadratic time and space complexities. In this paper we developed a new algorithm called ESPRIT-Forest for parallel hierarchical clustering of sequences. The algorithm achieves subquadratic time and space complexity and maintains a high clustering accuracy comparable to the standard method. The basic idea is to organize sequences into a pseudo-metric based partitioning tree for sub-linear time searching of nearest neighbors, and then use a new multiple-pair merging criterion to construct clusters in parallel using multiple threads. The new algorithm was tested on the human microbiome project (HMP) dataset, currently one of the largest published microbial 16S rRNA sequence dataset. Our experiment demonstrated that with the power of parallel computing it is now compu- tationally feasible to perform hierarchical clustering analysis of tens of millions of sequences. The software is available at http://www.acsu.buffalo.edu/∼yijunsun/lab/ESPRIT-Forest.html.