Quadratic Running Time Research Articles

LiveLattice: Real-time visualisation of tilted light-sheet microscopy data using a memory-efficient transformation algorithm.

Light-sheet fluorescence microscopy (LSFM), a prominent fluorescence microscopy technique, offers enhanced temporal resolution for imaging biological samples in four dimensions (4D; x, y, z, time). Some of the most recent implementations, including inverted selective plane illumination microscopy (iSPIM) and lattice light-sheet microscopy (LLSM), move the sample substrate at an oblique angle relative to the detection objective's optical axis. Data from such tilted-sample-scan LSFMs require subsequent deskewing and rotation for proper visualisation and analysis. Such data preprocessing operations currently demand substantial memory allocation and pose significant computational challenges for large 4D dataset. The consequence is prolonged data preprocessing time compared to data acquisition time, which limits the ability for live-viewing the data as it is being captured by the microscope. To enable the fast preprocessing of large light-sheet microscopy datasets without significant hardware demand, we have developed WH-Transform, a memory-efficient transformation algorithm for deskewing and rotating the raw dataset, significantly reducing memory usage and the run time by more than 10-fold for large image stacks. Benchmarked against the conventional method and existing software, our approach demonstrates linear runtime compared to the cubic and quadratic runtime of the other approaches. Preprocessing a raw 3D volume of 2 GB (512 × 1536 × 600 pixels) can be accomplished in 3 s using a GPU with 24 GB of memory on a single workstation. Applied to 4D LLSM datasets of human hepatocytes, lung organoid tissue and brain organoid tissue, our method provided rapid and accurate preprocessing within seconds. Importantly, such preprocessing speeds now allow visualisation of the raw microscope data stream in real time, significantly improving the usability of LLSM in biology. In summary, this advancement holds transformative potential for light-sheet microscopy, enabling real-time, on-the-fly data preprocessing, visualisation, and analysis on standard workstations, thereby revolutionising biological imaging applications for LLSM and similar microscopes.

Quasi-linear time heuristic to solve the Euclidean traveling salesman problem with low gap

The traveling salesman problem (TSP) is a well studied NP-hard optimization problem. We present a novel heuristic to find approximate solutions for the case of the TSP with Euclidean metric. Our pair-center algorithm runs in quasi-linear time and on linear space. In practical experiments on a variety of well known benchmarks the algorithm shows linearithmic (i.e., O(nlogn)) runtime. The solutions found by the pair-center algorithm are very good on smaller problem instances, and better than those generated by any other heuristic with at most quadratic runtime. Eventually, the average gap of the pair-center algorithm on all benchmark instances with less than 1001 points is 0.94% and for all instances with more than 1000 points up to 100 million points is 4.57%.

Fast calculation of p-values for one-sided Kolmogorov-Smirnov type statistics

A novel method for computing exact p-values of one-sided statistics from the Kolmogorov-Smirnov family is presented. It covers the Higher Criticism statistic, one-sided weighted Kolmogorov-Smirnov statistics, and the one-sided Berk-Jones statistics. In addition to p-values, the method can also be used for power analysis, finding alpha-level thresholds, and the construction of confidence bands for the empirical distribution function. With its quadratic runtime and numerical stability, the method easily scales to sample sizes in the hundreds of thousands and takes less than a second to run on a sample size of 25,000. This allows practitioners working on large data sets to use exact finite-sample computations instead of approximation schemes. The method is based on a reduction to the boundary-crossing probability of a pure jump stochastic process. FFT convolutions of two different sizes are then used to efficiently propagate the probabilities of the non-crossing paths. This approach has applications beyond statistics, for example in financial risk modeling.

Path norms on a matrix

We define row path norm and column path norm of a matrix and relate path norms with other standard matrix norms. A row (resp. column) path norm gives a path that maximizes relative row (resp. column) distances starting from the first row (resp. column). The comparison takes place from the last row (resp. column) to the first row (resp. column), tracing the path. We categorize different versions of path norms and provide algorithms to compute them. We show that brute-force methods to compute path norms have exponential running time. We give dynamic programming algorithms, which, in contrast, take quadratic running time for computing the path norms. We define path norms on Church numerals and Church pairs. Finally, we present applications of path norms in computing condition number, and ordering the solutions of magic squares and Latin squares

Engineering Nearly Linear-time Algorithms for Small Vertex Connectivity

Vertex connectivity is a well-studied concept in graph theory with numerous applications. A graph is k -connected if it remains connected after removing any k −1 vertices. The vertex connectivity of a graph is the maximum k such that the graph is k -connected. There is a long history of algorithmic development for efficiently computing vertex connectivity. Recently, two near linear-time algorithms for small k were introduced by Forster et al. [SODA 2020]. Prior to that, the best-known algorithm was one by Henzinger et al. [FOCS 1996] with quadratic running time when k is small. In this article, we study the practical performance of the algorithms by Forster et al. In addition, we introduce a new heuristic on a key subroutine called local cut detection, which we call degree counting. We prove that the new heuristic improves space-efficiency (which can be good for caching purposes) and allows the subroutine to terminate earlier. According to experimental results on random graphs with planted vertex cuts, random hyperbolic graphs, and real-world graphs with vertex connectivity between 4 and 8, the degree counting heuristic offers a factor of 2–4 speedup over the original non-degree counting version for small graphs and almost 20 times for some graphs with millions of edges. It also outperforms the previous state-of-the-art algorithm by Henzinger et al., even on relatively small graphs.

Scalable probabilistic truss decomposition using central limit theorem and H-index.

Truss decomposition is a popular notion of hierarchical dense substructures in graphs. In a nutshell, k-truss is the largest subgraph in which every edge is contained in at least k triangles. Truss decomposition aims to compute k-trusses for each possible value of k. There are many works that study truss decomposition in deterministic graphs. However, in probabilistic graphs, truss decomposition is significantly more challenging and has received much less attention; state-of-the-art approaches do not scale well to large probabilistic graphs. Finding the tail probabilities of the number of triangles that contain each edge is a critical challenge of those approaches. This is achieved using dynamic programming which has quadratic run-time and thus not scalable to real large networks which, quite commonly, can have edges contained in many triangles (in the millions). To address this challenge, we employ a special version of the Central Limit Theorem (CLT) to obtain the tail probabilities efficiently. Based on our CLT approach we propose a peeling algorithm for truss decomposition that scales to large probabilistic graphs and offers significant improvement over state-of-the-art. We also design a second method which progressively tightens the estimate of the truss value of each edge and is based on h-index computation. In contrast to our CLT-based approach, our h-index algorithm (1) is progressive by allowing the user to see near-results along the way, (2) does not sacrifice the exactness of final result, and (3) achieves all these while processing only one edge and its immediate neighbors at a time, thus resulting in smaller memory footprint. We perform extensive experiments to show the scalability of both of our proposed algorithms.

Improved graph formalism for quantum circuit simulation

Improving the simulation of quantum circuits on classical computers is important for understanding quantum advantage and increasing development speed. In this paper, we explore a new way to express stabilizer states and further improve the speed of simulating stabilizer circuits with a current existing approach. First, we discover a unique and elegant canonical form for stabilizer states based on graph states to better represent stabilizer states and show how to efficiently simplify stabilizer states to canonical form. Second, we develop an improved algorithm for graph state stabilizer simulation and establish limitations on reducing the quadratic runtime of applying controlled-Pauli $Z$ gates. We do so by creating a simpler formula for combining two Pauli-related stabilizer states into one. Third, to better understand the linear dependence of stabilizer states, we characterize all linearly dependent triplets, revealing symmetries in the inner products. Using our novel controlled-Pauli $Z$ algorithm, we improve runtime for inner product computation from $O(n^3)$ to $O(nd^2)$ where $d$ is the maximum degree of the graph.

Almost Linear Time Density Level Set Estimation via DBSCAN

In this work we focus on designing a fast algorithm for lambda-density level set estimation via DBSCAN clustering. Previous work (Jiang ICML’17, and Jang and Jiang ICML’19) shows that under some natural assumptions DBSCAN and its variant DBSCAN++ can be used to estimate the lambda-density level set with near-optimal Hausdorff distance, i.e., with rate O~(n^{-1/(2 * beta+D)}). However, to achieve this near-optimal rate, the current fastest DBSCAN algorithm needs near quadratic running time. This running time is not very practical for giant datasets. Usually when we are working with very large datasets we desire linear or almost linear time algorithms. With this motivation, in this work, we present a modified DBSCAN algorithm with near optimal Hausdorff distance for density level set estimation with O~(n) running time. In our empirical study, we show that our algorithm provides significant speedup over the previous algorithms, while achieving comparable solution quality.

A continuous strategy for collisionless gathering

Over the past decades, the Gathering problem, which asks to gather a group of robots in finite time given some restrictions, has been intensively studied. In this paper, we are given a group of n autonomous, dimensionless, deterministic, and anonymous robots, with bounded viewing range. Assuming a continuous time model, the goal is to gather these robots into one point in finite time. We introduce a simple convergence criterion that defines a new class of algorithms which perform gathering in O(nd) time, where d is the diameter of the initial robot configuration. We show that some gathering algorithms in the literature belong to this class and propose two new algorithms that belong to this class and have quadratic running time, namely, Go-To-The-Relative-Center algorithm (GTRC) and Safe-Go-To-The-Relative-Center algorithm (S-GTRC). We prove that the latter can perform gathering without collision by using a slightly more complex robot model: non oblivious, chiral, and luminous (i.e. robots have observable external memory, as in [8]). We also consider a variant of the Gathering problem, the Near-Gathering problem, in which robots must get close to each other without colliding. We show that S-GTRC solves the Near-Gathering problem in quadratic time and assumes a weaker robot model than the one assumed in the current state-of-the-art.

Closing the Gap for Makespan Scheduling via Sparsification Techniques

Makespan scheduling on identical machines is one of the most basic and fundamental packing problems studied in the discrete optimization literature. It asks for an assignment of n jobs to a set of m identical machines that minimizes the makespan. The problem is strongly NP-hard, and thus we do not expect a ([Formula: see text])-approximation algorithm with a running time that depends polynomially on [Formula: see text]. It has been recently shown that a subexponential running time on [Formula: see text] would imply that the Exponential Time Hypothesis (ETH) fails. A long sequence of algorithms have been developed that try to obtain low dependencies on [Formula: see text], the better of which achieves a quadratic running time on the exponent. In this paper we obtain an algorithm with an almost-linear dependency on [Formula: see text] in the exponent, which is tight under ETH up to logarithmic factors. Our main technical contribution is a new structural result on the configuration-IP integer linear program. More precisely, we show the existence of a highly symmetric and sparse optimal solution, in which all but a constant number of machines are assigned a configuration with small support. This structure can then be exploited by integer programming techniques and enumeration. We believe that our structural result is of independent interest and should find applications to other settings. We exemplify this by applying our structural results to the minimum makespan problem on related machines and to a larger class of objective functions on parallel machines. For all these cases, we obtain an efficient PTAS with running time with an almost-linear dependency on [Formula: see text] and polynomial in n.

ORBITS

With the emergence of the Internet of Things (IoT), time series streams have become ubiquitous in our daily life. Recording such data is rarely a perfect process, as sensor failures frequently occur, yielding occasional blocks of data that go missing in multiple time series. These missing blocks do not only affect real-time monitoring but also compromise the quality of online data analyses. Effective streaming recovery (imputation) techniques either have a quadratic runtime complexity, which is infeasible for any moderately sized data, or cannot recover more than one time series at a time. In this paper, we introduce a new online recovery technique to recover multiple time series streams in linear time. Our recovery technique implements a novel incremental version of the Centroid Decomposition technique and reduces its complexity from quadratic to linear. Using this incremental technique, missing blocks are efficiently recovered in a continuous manner based on previous recoveries. We formally prove the correctness of our new incremental computation, which yields an accurate recovery. Our experimental results on real-world time series show that our recovery technique is, on average, 30% more accurate than the state of the art while being vastly more efficient.

A linear time algorithm for the robust recoverable selection problem

The feasible solutions in the robust recoverable selection problem are subsets of size p that are to be selected from a ground set of size n. The objective is to construct a feasible solution in two sequential stages with two separate (but interleaved) cost structures. The fastest algorithm for this problem in the literature up to now has quadratic running time. We improve on this by developing an algorithm with linear running time.

Computing the Fréchet Gap Distance

Measuring the similarity of two polygonal curves is a fundamental computational task. Among alternatives, the Fréchet distance is one of the most well-studied similarity measures. Informally, the Fréchet distance is described as the minimum leash length required for a man on one of the curves to walk a dog on the other curve continuously from the starting to the ending points. In this paper we study a variant called the Fréchet gap distance. In the man and dog analogy, the Fréchet gap distance minimizes the difference of the longest and smallest leash lengths used over the entire walk. This measure in some ways better captures our intuitive notions of curve similarity, for example giving distance zero to translated copies of the same curve. The Fréchet gap distance was originally introduced by Filtser and Katz [19] in the context of the discrete Fréchet distance. Here we study the continuous version, which presents a number of additional challenges not present in discrete case. In particular, the continuous nature makes bounding and searching over the critical events a rather difficult task. For this problem we give an $$O(n^5\log n)$$ time exact algorithm and a more efficient $$O(n^2\log n +({n^2}/{{\varepsilon }})\log ({1}/{{\varepsilon }}))$$ time $$(1+{\varepsilon })$$ -approximation algorithm, where n is the total number of vertices of the input curves. Note that, ignoring logarithmic factors, for any constant $${\varepsilon }$$ our approximation has quadratic running time, matching the lower bound, assuming SETH [Bringmann, K.: Why walking the dog takes time: Fréchet distance has no strongly subquadratic algorithms unless SETH fails (2014)], for approximating the standard Fréchet distance for general curves.

On the Complexity Exponent of Polynomial System Solving

We present a probabilistic Las Vegas algorithm for solving sufficiently generic square polynomial systems over finite fields. We achieve a nearly quadratic running time in the number of solutions, for densely represented input polynomials. We also prove a nearly linear bit complexity bound for polynomial systems with rational coefficients. Our results are obtained using the combination of the Kronecker solver and a new improved algorithm for fast multivariate modular composition.

Parallel SLINK for big data

The major strength of hierarchical clustering algorithms is that it allows visual interpretations of clusters through dendrograms. Users can cut the dendrogram at different levels to get desired number of clusters. A major problem with hierarchical algorithms is their quadratic runtime complexity, which limits the amount of data that can be clustered in reasonable amount of time. Also, due to its agglomerative merging process, each iteration depends on the data of all previous iterations, making it difficult to parallelize. Thus, there is a need for an efficient parallel implementation of SLINK algorithm which can scale to big data. We present a parallel SLINK algorithm, sGridSLINK, for shared memory architectures. sGridSLINK produces exactly the same dendrogram as the classical SLINK algorithm. We also present, hGridSLINK, a parallel algorithm which fully exploits a multi-core cluster system. To the best of our knowledge, there is no hybrid parallel algorithm for SLINK available in the literature. The proposed algorithms exploit spatial locality of data to reduce the number of distance calculations. Adaptive gridding is used to counter skewness in data and to ensure load balancing. Extensive experiments are carried out to establish the efficiency and scalability of proposed parallel algorithms. sGridSLINK is approximately 840 times faster than the state-of-the-art algorithm using 55 threads on a 48-core machine on a real dataset having 6 million data points. It also achieves a speedup of 47.93 over the best known sequential SLINK, GridSLINK, on a real dataset using 48 threads on a 48-core machine. hGridSLINK achieves a maximum speedup of 68.26 on a 32-node cluster ($$32\times 4$$ processing elements) with respect to GridSLINK. The hGridSLINK algorithm is able to cluster 200 million data points in only 1317 s (less than 22 min). No existing parallel SLINK algorithm is capable of such efficient clustering of Big Data.

Dynamic Time Warping and Geometric Edit Distance

Dynamic Time Warping (DTW) and Geometric Edit Distance (GED) are basic similarity measures between curves or general temporal sequences (e.g., time series) that are represented as sequences of points in some metric space ( X , dist). The DTW and GED measures are massively used in various fields of computer science and computational biology. Consequently, the tasks of computing these measures are among the core problems in P. Despite extensive efforts to find more efficient algorithms, the best-known algorithms for computing the DTW or GED between two sequences of points in X = R d are long-standing dynamic programming algorithms that require quadratic runtime, even for the one-dimensional case d = 1, which is perhaps one of the most used in practice. In this article, we break the nearly 50-year-old quadratic time bound for computing DTW or GED between two sequences of n points in R by presenting deterministic algorithms that run in O ( n 2 log log log n / log log n ) time. Our algorithms can be extended to work also for higher-dimensional spaces R d , for any constant d , when the underlying distance-metric dist is polyhedral (e.g., L 1 , L infin ).

A Rainbow Coverage Path Planning for a Patrolling Mobile Robot With Circular Sensing Range

In this paper, we proposed a coverage path (CP) planning approach for a mobile robot moving in a dynamically changing environment. Our family of algorithms begins by finding the first path around the center of interior obstacles/disks of a given target region (TR) through the Graham scan algorithm. The first path is then used as a foundational path to generate a collision free, first order differentiable, and observable CP through a complete set of input and output transformation algorithms which together form the rainbow CP planning approach. The last algorithm of the rainbow CP planning approach finds a sufficient number of observation points on the CP needed to observe the TR. The novelty of our rainbow CP planning approach is that it partitions the TR into different shapes with different properties needed to obtain complete coverage while achieving first order path differentiability. The main technical contributions of the proposed approach is to provide a holistic solution that segments any TR, uses triangulation to determine the line of sights and observation points, and computes the collision-free CP within a quadratic runtime. The proposed method can be readily generalized to address problems of higher dimensions, and it is scalable with respect to the size of TR and the number of robots. Computer simulations are used to illustrate the effectiveness and correctness of the proposed approach.

Extended suffix array construction using Lyndon factors

In this paper, we are extending the novel approach of incremental suffix array construction using Lyndon factorization to the construction of extended suffix array where extended suffix array is the suffix array along with the corresponding longest common prefix (LCP) array. Main motive behind the incremental and simultaneous construction of suffix array and LCP array is that both involve in calculating the order information by considering the common prefixes of the suffixes. As local suffixes once sorted have the same sorted order when these are merged with sorted suffixes of another Lyndon factor. So, merging of Lyndon factors is simply merging of two sorted lists of suffixes of these Lyndon factors. Also, the two sorted orders coincide thus making the merging of Lyndon factors a simple merging of two sorted lists of suffixes. Incremental LCP construction simultaneously saves a lot of computation and hence time. The proposed approach has quadratic run time and the disk working space requirement is O(n). Experiments also show the performance gain of our approach in terms of time over the existing method of incremental construction.

Efficient Embedding of Scale-Free Graphs in the Hyperbolic Plane

Hyperbolic geometry appears to be intrinsic in many large real networks. We construct and implement a new maximum likelihood estimation algorithm that embeds scale-free graphs in the hyperbolic space. All previous approaches of similar embedding algorithms require at least a quadratic runtime. Our algorithm achieves quasi-linear runtime, which makes it the first algorithm that can embed networks with hundreds of thousands of nodes in less than one hour. We demonstrate the performance of our algorithm on artificial and real networks. In all typical metrics, such as log-likelihood and greedy routing, our algorithm discovers embeddings that are very close to the ground truth.

Efficient denial constraint discovery with hydra

Denial constraints (DCs) are a generalization of many other integrity constraints (ICs) widely used in databases, such as key constraints, functional dependencies, or order dependencies. Therefore, they can serve as a unified reasoning framework for all of these ICs and express business rules that cannot be expressed by the more restrictive IC types. The process of formulating DCs by hand is difficult, because it requires not only domain expertise but also database knowledge, and due to DCs' inherent complexity, this process is tedious and error-prone. Hence, an automatic DC discovery is highly desirable: we search for all valid denial constraints in a given database instance. However, due to the large search space, the problem of DC discovery is computationally expensive. We propose a new algorithm H ydra , which overcomes the quadratic runtime complexity in the number of tuples of state-of-the-art DC discovery methods. The new algorithm's experimentally determined runtime grows only linearly in the number of tuples. This results in a speedup by orders of magnitude, especially for datasets with a large number of tuples. Hydra can deliver results in a matter of seconds that to date took hours to compute.