Worst-case Running Time Research Articles

Soundness unknotted: An efficient soundness checking algorithm for arbitrary cyclic process models by loosening loops

Although domain experts usually create business process models, these models can still contain errors. For this reason, research and practice establish criteria for process models to provide confidence in the correctness or correct behavior of processes. One widespread criterion is soundness, which guarantees the absence of deadlocks and lacks of synchronization. Checking soundness of process models is not trivial. However, cyclic process models additionally increase the complexity to check soundness. This paper presents a novel approach for verifying soundness that has an efficient cubic worst-case runtime behavior, even for arbitrary cyclic process models. This approach relies on three key techniques — loop conversion, loop reduction, and loop decomposition — to convert any cyclic process model into a set of acyclic process models. Using this approach, we have developed five straightforward rules to verify the soundness, reusing existing approaches for checking soundness of acyclic models.

Simple & Optimal Quantile Sketch: Combining Greenwald-Khanna with Khanna-Greenwald

Estimating the ε-approximate quantiles or ranks of a stream is a fundamental task in data monitoring. Given a stream x_1,..., x_n from a universe \mathcalU with total order, an additive-error quantile sketch \mathcalM allows us to approximate the rank of any query y\in \mathcalU up to additive ε n error. In 2001, Greenwald and Khanna gave a deterministic algorithm (GK sketch) that solves the ε-approximate quantiles estimation problem using O(ε^-1 łog(ε n)) space \citegreenwald2001space ; recently, this algorithm was shown to be optimal by Cormode and Vesleý in 2020 \citecormode2020tight. However, due to the intricacy of the GK sketch and its analysis, over-simplified versions of the algorithm are implemented in practical applications, often without any known theoretical guarantees. In fact, it has remained an open question whether the GK sketch can be simplified while maintaining the optimal space bound. In this paper, we resolve this open question by giving a simplified deterministic algorithm that stores at most (2 + o(1))ε^-1 łog (ε n) elements and solves the additive-error quantile estimation problem; as a side benefit, our algorithm achieves a smaller constant factor than the \frac11 2 ε^-1 łog(ε n) space bound in the original GK sketch~\citegreenwald2001space. Our algorithm features an easier analysis and still achieves the same optimal asymptotic space complexity as the original GK sketch. Lastly, our simplification enables an efficient data structure implementation, with a worst-case runtime of O(łog(1/ε) + łog łog (ε n)) per-element for the ordinary ε-approximate quantile estimation problem. Also, for the related "weighted'' quantile estimation problem, we give efficient data structures for our simplified algorithm which guarantee a worst-case per-element runtime of O(łog(1/ε) + łog łog (ε W_n/w_\textrmmin )), achieving an improvement over the previous upper bound of \citeassadi2023generalizing.

Worst-Case Analysis of Heapsort, Exactly

Abstract This paper completes analysis of the worst-case running time of $ {\tt{Heapsort}}$ measured by the number of comparisons of keys performed while sorting. A derivation of an exact formula for the maximum number of comparisons of keys performed by $ {\tt{Heapsort}} $ on any array of size $ N \geq 2 $ is presented. It is equal to $$ \begin{align}& \nonumber 2(N-1)\lceil \lg N \rceil - 2 ^{\lceil \lg N \rceil +1} - 2 s_2(N) - e_2(N) + \min (\lceil \lg N \rceil, 3) + 5 + c, \end{align} $$ where $s_2(N)$ is the sum of digits of the binary representation of $N$, $e_2(N)$ is the exponent of $2$ in the $N$’s prime factorization and $ c $ is a binary function on the set of positive integers defined by $$ \begin{align}& \nonumber c = \left\{ \begin{array}{@{}ll} 1 \text{ if} \; N \leq 2 ^{\lceil \lg N \rceil} - 4 \\[4pt] 0 \text{ otherwise}. \end{array} \right. \end{align} $$ The above formula allows for deciding, in $ O(N \log N) $ time, if any given $ N $-element array is a worst-case array for $ {\tt{Heapsort}} $. Its proof yields an algorithm for construction, in $ O(N \log N) $ time, of worst-case arrays of arbitrary sizes $ N \geq 2 $ for $ {\tt{Heapsort}} $.

Submodularity-based false data injection attack scheme in multi-agent dynamical systems

Consensus in multi-agent dynamical systems is prone to be sabotaged by the adversary, which has attracted much attention due to its key role in broad applications. In this paper, we study a new false data injection (FDI) attack design problem, where the adversary with limited capability aims to select a subset of agents and manipulate their local multi-dimensional states to maximize the consensus convergence error. We first formulate the FDI attack design problem as a combinatorial optimization problem and prove it is NP-hard. Then, based on the submodularity optimization theory, we provide the necessary and sufficient conditions to guarantee that the convergence error is a submodular function of the set of compromised agents, satisfying the property of diminishing marginal returns. In other words, the benefit of adding an extra agent to the compromised set decreases as that set becomes larger. With this property, we exploit the greedy scheme to find the optimal compromised agent set that can produce the maximum convergence error when adding one extra agent to that set each time. Thus, the FDI attack set selection algorithms are developed to obtain the near-optimal subset of the compromised agents. Furthermore, we derive the analytical suboptimality bounds and the worst-case running time under the proposed algorithm. Extensive simulation results are conducted to show the effectiveness of the proposed algorithm.

Actis: A Strictly Local Union–Find Decoder

Fault-tolerant quantum computing requires classical hardware to perform the decoding necessary for error correction. The Union–Find decoder is one of the best candidates for this. It has remarkably organic characteristics, involving the growth and merger of data structures through nearest-neighbour steps; this naturally suggests the possibility of its realisation using a lattice of simple processors with nearest-neighbour links. In this way the computational load can be distributed with near-ideal parallelism. Here we show for the first time that this strict (rather than partial) locality is practical, with a worst-case runtime O(d3) and mean runtime subquadratic in the surface code distance d. A novel parity-calculation scheme is employed which can simplify previously proposed architectures, and our approach is optimised for circuit-level noise. We compare our local realisation with one augmented by long-range links; while the latter is of course faster, we note that local asynchronous logic could negate the difference.

Approximating ( k,ℓ )-Median Clustering for Polygonal Curves

In 2015, Driemel, Krivošija, and Sohler introduced the k,ℓ -median clustering problem for polygonal curves under the Fréchet distance. Given a set of input curves, the problem asks to find k median curves of at most ℓ vertices each that minimize the sum of Fréchet distances over all input curves to their closest median curve. A major shortcoming of their algorithm is that the input curves are restricted to lie on the real line. In this article, we present a randomized bicriteria-approximation algorithm that works for polygonal curves in ℝ d and achieves approximation factor (1+ɛ) with respect to the clustering costs. The algorithm has worst-case running time linear in the number of curves, polynomial in the maximum number of vertices per curve (i.e., their complexity), and exponential in d , ℓ, 1/ɛ and 1/δ (i.e., the failure probability). We achieve this result through a shortcutting lemma, which guarantees the existence of a polygonal curve with similar cost as an optimal median curve of complexity ℓ, but of complexity at most 2ℓ -2, and whose vertices can be computed efficiently. We combine this lemma with the superset sampling technique by Kumar et al. to derive our clustering result. In doing so, we describe and analyze a generalization of the algorithm by Ackermann et al., which may be of independent interest.

Short attribute-based signatures for arbitrary Turing machines from standard assumptions

This paper presents the first attribute-based signature (ABS) scheme supporting signing policies representable by Turing machines (TM), based on well-studied computational assumptions. Our work supports arbitraryTMs as signing policies in the sense that the TMs can accept signing attribute strings of unbounded polynomial length and there is no limit on their running time, description size, or space complexity. Moreover, we are able to achieve input-specific running time for the signing algorithm. All other known expressive ABS schemes could at most support signing policies realizable by either arbitrary polynomial-size circuits or TMs having a pre-determined upper bound on the running time. Consequently, those schemes can only deal with signing attribute strings whose lengths are a priori bounded, as well as suffers from the worst-case running time problem. On a more positive note, for the first time in the literature, the signature size of our ABS scheme only depends on the size of the signed message and is completely independent of the size of the signing policy under which the signature is generated. This is a significant achievement from the point of view of communication efficiency. Our ABS construction makes use of indistinguishability obfuscation (IO) for polynomial-size circuits and certain IO-compatible cryptographic tools. Note that, all of these building blocks including IO for polynomial-size circuits are currently known to be realizable under well-studied computational assumptions.

Spork: Structured Merge for Java With Formatting Preservation

The highly parallel workflows of modern software development have made merging of source code a common activity for developers. The state of the practice is based on line-based merge, which is ubiquitously used with "git merge". Line-based merge is however a generalized technique for any text that cannot leverage the structured nature of source code, making merge conflicts a common occurrence. As a remedy, research has proposed structured merge tools, which typically operate on abstract syntax trees instead of raw text. Structured merging greatly reduces the prevalence of merge conflicts but suffers from important limitations, the main ones being a tendency to alter the formatting of the merged code and being prone to excessive running times. In this paper, we present SPORK, a novel structured merge tool for JAVA. SPORK is unique as it preserves formatting to a significantly greater degree than comparable state-of-the-art tools. SPORK is also overall faster than the state of the art, in particular significantly reducing worst-case running times in practice. We demonstrate these properties by replaying 1740 real-world file merges collected from 119 open-source projects, and further demonstrate several key differences between SPORK and the state of the art with in-depth case studies.

Fast Exact Dynamic Time Warping on Run-Length Encoded Time Series

Dynamic Time Warping (DTW) is a well-known similarity measure for time series. The standard dynamic programming approach to compute the DTW distance of two length-n time series, however, requires O(n^2) time, which is often too slow for real-world applications. Therefore, many heuristics have been proposed to speed up the DTW computation. These are often based on lower bounding techniques, approximating the DTW distance, or considering special input data such as binary or piecewise constant time series. In this paper, we present a first exact algorithm to compute the DTW distance of two run-length encoded time series whose running time only depends on the encoding lengths of the inputs. The worst-case running time is cubic in the encoding length. In experiments we show that our algorithm is indeed fast for time series with short encoding lengths.

A Batch-dynamic Suitor Algorithm for Approximating Maximum Weighted Matching

Matching is a popular combinatorial optimization problem with numerous applications in both commercial and scientific fields. Computing optimal matchings w.r.t. cardinality or weight can be done in polynomial time; still, this task can become infeasible for very large networks. Thus, several approximation algorithms that trade solution quality for a faster running time have been proposed. For networks that change over time, fully dynamic algorithms that efficiently maintain an approximation of the optimal matching after a graph update have been introduced as well. However, no semi- or fully dynamic algorithm for (approximate) maximum weighted matching has been implemented. In this article, we focus on the problem of maintaining a \( 1/2 \) -approximation of a maximum weighted matching (MWM) in fully dynamic graphs. Limitations of existing algorithms for this problem are (i) high constant factors in their time complexity, (ii) the fact that none of them supports batch updates, and (iii) the lack of a practical implementation, meaning that their actual performance on real-world graphs has not been investigated. We propose and implement a new batch-dynamic \( 1/2 \) -approximation algorithm for MWM based on the Suitor algorithm and its local edge domination strategy [Manne and Halappanavar, IPDPS 2014]. We provide a detailed analysis of our algorithm and prove its approximation guarantee. Despite having a worst-case running time of \( \mathcal {O}(n + m) \) for a single graph update, our extensive experimental evaluation shows that our algorithm is much faster in practice. For example, compared to a static recomputation with sequential Suitor , single-edge updates are handled up to \( 10^5\times \) to \( 10^6\times \) faster, while batches of \( 10^4 \) edge updates are handled up to \( 10^2\times \) to \( 10^3\times \) faster.

Fast k-Nearest Neighbor on a Navigation Mesh

We consider the k-Nearest Neighbour problem in a two-dimensional Euclidean plane with obstacles (OkNN). Existing and state of the art algorithms for OkNN are based on incremental visibility graphs and as such suffer from a well known disadvantage: costly and online visibility checking with quadratic worst-case running times. In this work we develop a new OkNN algorithm which avoids these disadvantages by representing the traversable space as a collection of convex polygons; i.e. a Navigation Mesh. We then adapt an recent and optimal navigation mesh algorithm, Polyanya, from the single-source single-target setting to the the multi-target case. We also give two new heuristics for OkNN. In a range of empirical comparisons we show that our approach can be orders of magnitude faster than competing methods that rely on visibility graphs.

Exploring a genotype based formalisation for tree adjoining grammar derivations

Tree Adjoining Grammars (TAGs) are very useful psycholinguistic formalisms for syntax and dependency analysis of phrase structures. Since natural languages are finitely ambiguous, TAGs are ideal to model them being mildly context sensitive. But these grammars are very hard to parse as they have a worst case complexity of $$O(n^6)$$ . In reality most conventional TAG parsing algorithms run in $$O(n^3)$$ and give the most probable parse, but trying to extract multiple ambiguous parses for a given phrase degrades the performance of the traditional TAG parsing algorithms toward worst case runtime, especially for longer sentences. Ambiguity in TAGs are not as well understood as in CFGs due to their complex derivation process; hence one of the ways to understand it is to find a finite set of ambiguous derivations for the given phrase structure. In this article we extend the definition of the containing formalism introduced as GATAGs on which a genetic algorithm can be deployed in order to find ambiguous derivation structures for longer sentences. We shall formalise the genotypes, phenotypes and the fitness functions for the entailing genetic algorithm, exploring various avenues for their efficient computations. Our main objective here is to explore the possibility of random derivations evolving to good derivations though a natural selection.

The New Matrix Model of Computation Based Purely on Quite a New Concept of the Matrix Computations for Extremely Quick Web Pages Loading

We all dream of quick loading. Quicker than it is now. So that it loads immediately. What is needed for this? There are a lot of things to do. The most important things in it are computations. To speed up loading, we need to speed up computations. If we will find the way to multiply large numbers quicker than we have, the loading will be much quicker. How to do that? We need to multiply large numbers in time O(log n). How is that possible? A new model of computation may solve this problem. These are the algorithms that require considerably less amount of resources to perform them. The time complexity of the algorithm is the main (key) resource that we need to reduce to get the desired complexity. It seems incredible, but it is possible. We will get this through the sorting array. Best, worst, and average cases of a given algorithm could be considered for each particular input instance of the problem when analyzing algorithms. The worst-case complexity is the most used in algorithm analysis, it gives an upper bound on the resources required by the algorithm. Thus, the discovery of better algorithms brings the upper bound on the worst-case running time down. This paper presents the new matrix model of computation, which is based on the concept of the new matrix computations for advanced computing. The paper intends to prove the existence of better algorithms for any given input instance of the worst-case time complexity M(n) = O(n2) that take O(log n) and provide extremely quick web pages loading and create a new topic in complexity.

Algorithms for Finding Shortest Paths in Networks with Vertex Transfer Penalties

In this paper we review many of the well-known algorithms for solving the shortest path problem in edge-weighted graphs. We then focus on a variant of this problem in which additional penalties are incurred at the vertices. These penalties can be used to model things like waiting times at road junctions and delays due to transfers in public transport. The usual way of handling such penalties is through graph expansion. As an alternative, we propose two variants of Dijkstra’s algorithm that operate on the original, unexpanded graph. Analyses are then presented to gauge the relative advantages and disadvantages of these methods. Asymptotically, compared to using Dijkstra’s algorithm on expanded graphs, our first variant is faster for very sparse graphs but slower with dense graphs. In contrast, the second variant features identical worst-case run times.

A Quantum Interior Point Method for LPs and SDPs

We present a quantum interior point method (IPM) for semi-definite programs that has a worst-case running time of Õ( n 2.5 / ξ 2 μ κ 3 log(1/ϵ)). The algorithm outputs a pair of matrices ( S,Y ) that have objective value within ϵ of the optimal and satisfy the constraints approximately to error xi. The parameter mu is at most √2 n while kappa is an upper bound on the condition number of the intermediate solution matrices arising in the classical IPM. For the case where κ ≪ n 5/6 , our method provides a significant polynomial speedup over the best-known classical semi-definite program solvers that have a worst-case running time of Õ( n 6 ). For linear programs, our algorithm has a running time of Õ( n 1.5 / ξ 2 μ κ 3 log (1/ϵ)) with the same guarantees and with parameter μ < √2 n . Our technical contributions include an efficient quantum procedure for solving the Newton linear systems arising in the classical IPMs, an efficient pure state tomography algorithm, and an analysis of the IPM where the linear systems are solved approximately. Our results pave the way for the development of quantum algorithms with significant polynomial speedups for applications in optimization and machine learning.

Inferring Lower Runtime Bounds for Integer Programs

We present a technique to infer lower bounds on the worst-case runtime complexity of integer programs, where in contrast to earlier work, our approach is not restricted to tail-recursion. Our technique constructs symbolic representations of program executions using a framework for iterative, under-approximating program simplification. The core of this simplification is a method for (under-approximating) program acceleration based on recurrence solving and a variation of ranking functions. Afterwards, we deduce asymptotic lower bounds from the resulting simplified programs using a special-purpose calculus and an SMT encoding. We implemented our technique in our tool LoAT and show that it infers non-trivial lower bounds for a large class of examples.

Computing the k-Visibility Region of a Point in a Polygon

Two points p and q in a simple polygon P are k-visible when the line segment pq crosses the boundary of P at most k times. Given a query point q, a positive integer k, and a polygon P, we design an algorithm that computes the region of P that is k-visible from q in O(nk) time, where n denotes the number of vertices of P. This region is called the k-visibility region of q. This is the first algorithm parameterized in terms of k, resulting in an asymptotically faster worst-case running time compared to previous algorithms when k is $o(\log {n})$ , and bridging the gap between the O(n)-time algorithm for computing the 0-visibility region of q in P and the $O(n\log n)$ -time algorithm for computing the k-visibility region of q in P for any k. We also design a data structure of size O(n5) that supports visibility queries, returning the k-visible region of P for any arbitrary query point q in $O(\log {n}+m)$ time, where m denotes the number of vertices on the boundary of the output visibility region.

Correction to: Reoptimization Time Analysis of Evolutionary Algorithms on Linear Functions Under Dynamic Uniform Constraints

In the article Reoptimization Time Analysis of Evolutionary Algorithms on Linear Functions Under Dynamic Uniform Constraints, we claimed a worst-case runtime of and for the Multi-Objective Evolutionary Algorithm and the Multi-Objective Genetic Algorithm, respectively, on linear profit functions under dynamic uniform constraint, where denotes the difference between the original constraint bound B and the new one. The technique used to prove these results contained an error. We correct this mistake and show a weaker bound of for both algorithms instead.

Optimal-size problem kernels for d-Hitting Set in linear time and space

The known linear-time kernelizations for d-Hitting Set guarantee linear worst-case running times using a quadratic-size data structure (that is not fully initialized). Getting rid of this data structure, we show that problem kernels of asymptotically optimal size O(kd) for d-Hitting Set are computable in linear time and space. Additionally, we experimentally compare the linear-time kernelizations for d-Hitting Set to each other and to a classical data reduction algorithm due to Weihe.

Outage Analysis in Cognitive Radio Networks With Energy Harvesting and Q-Routing

The present work explores mitigation in end-to-end outage probability in an energy harvesting (EH) enabled cognitive radio networks (CRNs) through reinforcement learning (RL) based multi-hop Q-routing. The operation of CRN follows a frame structure that includes cooperative spectrum sensing (CSS), based on the decision of which, secondary transmit nodes either do EH from the primary user (PU) signal or make an opportunistic data transmission. In either operation, both PU reappearance and disappearance probabilities are considered in mathematical analysis. An optimization problem is formulated that minimizes the outage probability in the CRN under the constraints of primary user interference protection, individual secondary link throughput, and energy causality in EH. The closed-form expressions are derived to find the optimal values of sensing duration, secondary power allocation fraction on SS and data transmission. The present multi-hop CRN studies RL-based Q-routing in different network topologies and analyzes the worst-case runtime complexities. It is observed that the tree structure based network reduces the complexity of Q-routing over the other topologies and provides a significant gain on the outage. The present work improves the CRN outage performance by 11.01% and 39.89% over the existing techniques.