We consider the problem of sorting n elements subject to persistent random comparison errors. In this problem, each comparison between two elements can be wrong with some fixed (small) probability p, and comparing the same pair of elements multiple times always yields the same result. Sorting perfectly in this model is impossible, and the objective is to minimize the dislocation of each element in the output sequence, i.e., the difference between its position in the sequence and its true rank. In this paper, we present the first O(nlog n)-time sorting algorithm that guarantees both O(log n) maximum dislocation and O(n) total dislocation with high probability when p<1/4. This settles the time complexity sorting with persistent comparison errors in the given range of p and shows that comparison errors do not increase its computational difficulty. Indeed, Ω(nlog n) time is necessary to archive a maximum dislocation of O(log n) even without comparison errors. Moreover, we prove that no algorithm can guarantee a maximum dislocation of o(log n) with high probability, nor a total dislocation of o(n) in expectation. To develop our sorting algorithm, we solve two related sub-problems, which might be of independent interest. More precisely, we show that O(log n) time suffices to find a position in which to insert a new element x in an almost-sorted sequence S of n elements having dislocation at most d=Ω(log n), so that the dislocation of x in the resulting sequence is O(d) with high probability (which can be equivalently thought as the problem of estimating the rank of x in S). We also show that the maximum (resp. total) dislocation of an approximately sorted sequence S of n elements can be lowered to O(log n) (resp. O(n)) in O(nd) time, w.h.p., where d is an upper bound on the maximum dislocation of S.

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.

We study the problem of computing a longest increasing subsequence in a sequence S of n distinct elements in the presence of persistent comparison errors. In this model, Braverman and Mossel (Noisy sorting without resampling, SODA 2008, pages 268–276, 2008) every comparison between two elements can return the wrong result with some fixed (small) probability p, and comparisons cannot be repeated. Computing the longest increasing subsequence exactly is impossible in this model, therefore, the objective is to identify a subsequence that (i) is indeed increasing and (ii) has a length that approximates the length of the longest increasing subsequence. We present asymptotically tight upper and lower bounds on both the approximation factor and the running time. In particular, we present an algorithm that computes an $O(\log n)$-approximation in $O(n\log n)$ time, with high probability. This approximation relies on the fact that we can approximately sort (Geissmann et al. Optimal Sorting with Persistent Comparison Errors, ArXiv e-prints 1804.07575, 2018) n elements in $O(n\log n)$ time such that the maximum dislocation of an element is $O(\log n)$. For the lower bounds, we prove that (i) there is a set of sequences, such that on a sequence picked randomly from this set every algorithm must return an ${\Omega }(\log n)$-approximation with high probability, and (ii) any $\log n$-approximation algorithm for longest increasing subsequence requires ${\Omega }(n \log n)$ comparisons, even in the absence of errors.

We present robust, adaptive routing policies for time-varying networks (temporal graphs) in the presence of random edge-failures. Such a policy answers the following question: How can a traveler navigate a time-varying network where edges fail randomly in order to maximize the traveler’s preference with respect to the arrival time? Our routing policy is computable in near-linear time in the number of edges in the network (for the case when the edges fail independently of each other). Using our robust routing policy, we show how to travel in a public transit network where the vehicles experience delays. To validate our approach, we present experiments using real-world delay data from the public transit network of the city of Zurich. Our experiments show that we obtain significantly improved outcomes compared to a purely schedule-based policy: The traveler is on time 5-11 percentage points more often for most destinations and 20-40 percentage points more often for certain remote destinations. Our implementation shows that the approach is fast enough for real-time usage. It computes a policy for 1-hour long journeys in around 0.1 seconds. 2012 ACM Subject Classification Theory of computation → Graph algorithms analysis

We study sorting of permutations by random swaps if each comparison gives the wrong result with some fixed probability $p<1/2$. We use this process as prototype for the behaviour of randomized, comparison-based optimization heuristics in the presence of noisy comparisons. As quality measure, we compute the expected fitness of the stationary distribution. To measure the runtime, we compute the minimal number of steps after which the average fitness approximates the expected fitness of the stationary distribution. We study the process where in each round a random pair of elements at distance at most $r$ are compared. We give theoretical results for the extreme cases $r=1$ and $r=n$, and experimental results for the intermediate cases. We find a trade-off between faster convergence (for large $r$) and better quality of the solution after convergence (for small $r$).

We consider the problem of sorting n elements in the case of persistent comparison errors. In this problem, each comparison between two elements can be wrong with some fixed (small) probability p, and comparisons cannot be repeated (Braverman and Mossel, SODA'08). Sorting perfectly in this model is impossible, and the objective is to minimize the dislocation of each element in the output sequence, that is, the difference between its true rank and its position. Existing lower bounds for this problem show that no algorithm can guarantee, with high probability, maximum dislocation and total dislocation better than Omega(log n) and Omega(n), respectively, regardless of its running time. In this paper, we present the first O(n log n)-time sorting algorithm that guarantees both O(log n) maximum dislocation and O(n) total dislocation with high probability. This settles the time complexity of this problem and shows that comparison errors do not increase its computational difficulty: a sequence with the best possible dislocation can be obtained in O( n log n) time and, even without comparison errors, Omega( n log n) time is necessary to guarantee such dislocation bounds. In order to achieve this optimality result, we solve two sub-problems in the persistent error comparisons model, and the respective methods have their own merits for further application. One is how to locate a position in which to insert an element in an almost-sorted sequence having O(log n) maximum dislocation in such a way that the dislocation of the resulting sequence will still be O(log n). The other is how to simultaneously insert m elements into an almost sorted sequence of m different elements, such that the resulting sequence of 2m elements remains almost sorted.

In real world applications, important resources like energy are saved by deliberately using so-called low-cost operations that are less reliable. Some of these approaches are based on a dual mode technology where it is possible to choose between high-energy operations (always correct) and low-energy operations (prone to errors), and thus enable to trade energy for correctness. In this work we initiate the study of algorithms for solving optimization problems that in their computation are allowed to choose between two types of operations: high-energy comparisons (always correct but expensive) and low-energy comparisons (cheaper but prone to errors). For the errors in low-energy comparisons, we assume the persistent setting, which usually makes it impossible to achieve optimal solutions without high-energy comparisons. We propose to study a natural complexity measure which accounts for the number of operations of either type separately. We provide a new family of algorithms which, for a fairly large class of maximization problems, return a constant approximation using only polylogarithmic many high-energy comparisons and only O(n log n) low-energy comparisons. This result applies to the class of p-extendible system s [Mestre, 2006], which includes several NP-hard problems and matroids as a special case (p=1). These algorithmic solutions relate to some fundamental aspects studied earlier in different contexts: (i) the approximation guarantee when only ordinal information is available to the algorithm; (ii) the fact that even such ordinal information may be erroneous because of low-energy comparisons and (iii) the ability to approximately sort a sequence of elements when comparisons are subject to persistent errors. Finally, our main result is quite general and can be parametrized and adapted to other error models.

We present the first near-linear work and poly-logarithmic depth algorithm for computing a minimum cut in an undirected graph. Previous parallel algorithms with poly-logarithmic depth required at least quadratic work in the number of vertices. In a graph with n vertices and m edges, our randomized algorithm computes the minimum cut with high probability in O(m log(4) n) work and O(log(3) n) depth. This result is obtained by parallelizing a data structure that aggregates weights along paths in a tree, in addition exploiting the connection between minimum cuts and approximate maximum packings of spanning trees. In addition, our algorithm improves upon bounds on the number of cache misses incurred to compute a minimum cut.

We study very simple sorting algorithms based on a probabilistic comparator model. In this model, errors in comparing two elements are due to (1) the energy or effort put in the comparison and (2) the difference between the compared elements. Such algorithms repeatedly compare and swap pairs of randomly chosen elements, and they correspond to natural Markovian processes. The study of these Markov chains reveals an interesting phenomenon. Namely, in several cases, the algorithm that repeatedly compares only adjacent elements is better than the one making arbitrary comparisons: in the long-run, the former algorithm produces sequences that are "better sorted". The analysis of the underlying Markov chain poses interesting questions as the latter algorithm yields a nonreversible chain, and therefore its stationary distribution seems difficult to calculate explicitly. We nevertheless provide bounds on the stationary distributions and on the mixing time of these processes in several restrictions.

We show how to compute the minimum cut of a graph cache-efficiently. Let B be the width of a cache line and M be the size of the cache. On a graph with V vertices and E edges, we give a cache oblivious algorithm that incurs O(⌈E/B (log ^4 E) log _M/B E⌉ ) cache misses and a simpler one that incurs O(⌈V^2/Blog ^3 V⌉ ) cache misses.

We present a sorting algorithm for the case of recurrent random comparison errors. The algorithm essentially achieves simultaneously good properties of previous algorithms for sorting n distinct elements in this model. In particular, it runs in O(n^2) time, the maximum dislocation of the elements in the output is O(log n), while the total dislocation is O(n). These guarantees are the best possible since we prove that even randomized algorithms cannot achieve o(log n) maximum dislocation with high probability, or o(n) total dislocation in expectation, regardless of their running time.

We study the number of inversions after running the Insertion Sort or Quicksort algorithm, when errors in the comparisons occur with some probability. We investigate the case in which probabilities depend on the difference between the two numbers to be compared and only differences up to some threshold τ are prone to errors. We give upper bounds for this model and show that for constant τ , the expected number of inversions is linear in the number of elements to be sorted. For Insertion Sort, we also yield an upper bound on the expected number of runs, i.e., the number of consecutive increasing subsequences.

We consider the problem of collectively delivering some message from a specified source to a designated target location in a graph, using multiple mobile agents. Each agent has a limited energy which constrains the distance it can move. Hence multiple agents need to collaborate to move the message, each agent handing over the message to the next agent to carry it forward. Given the positions of the agents in the graph and their respective budgets, the problem of finding a feasible movement schedule for the agents can be challenging. We consider two variants of the problem: in non-returning delivery, the agents can stop anywhere; whereas in returning delivery, each agent needs to return to its starting location, a variant which has not been studied before. We first provide a polynomial-time algorithm for returning delivery on trees, which is in contrast to the known (weak) NP-hardness of the non-returning version. In addition, we give resource-augmented algorithms for returning delivery in general graphs. Finally, we give tight lower bounds on the required resource augmentation for both variants of the problem. In this sense, our results close the gap left by previous research.

Counting the number of permutations of a given total displacement is equivalent to counting weighted Motzkin paths of a given area (Guay-Paquet and Petersen [11]). The former combinatorial problem is still open. In this work we show that this connection allows to construct efficient algorithms for counting and for sampling such permutations. These algorithms provide a tool to better understand the original combinatorial problem. A by-product of our approach is a different way of counting based on certain "building sequences" for Motzkin paths, which may be of independent interest.

In a faulty environment, comparisons between two elements with respect to an underlying linear order can come out right or go wrong. A wrong comparison is a recurring comparison fault if comparing the same two elements yields the very same result each time we compare the elements. We examine the impact of such faults on the elementary problems of sorting a set of distinct elements and finding a minimum element in such a set. The more faults occur, the worse the approaches to solve these problems can become and we parametrize our analysis by an upper bound k on the number of faults. We first explain that reconstructing the sorted order of the elements is impossible in the presence of even one fault. Then, we focus on the maximum information content we get by performing all possible comparisons. We consider two natural approaches for sorting the elements that involve knowledge of the outcomes of all comparisons: the first approach finds a permutation (compatible solution) that contradicts at most k times the outcomes of comparisons, and the second approach sorts the elements by the number of times an element is returned to be larger in the outcomes of its comparisons with all other elements (score solution). In such permutations the elements can be dislocated from their positions in the linear order. We measure the quality of such permutations by three measures: the maximum dislocation of an element, the sum of dislocations of all elements, and the Kemeny distance compared to the linear order. We show for compatible solutions that the Kemeny distance is at most 2k, the sum of dislocations at most 4k, and the maximum dislocation at most 2k. In score solutions the Kemeny distance is smaller than 4k, the sum of dislocations smaller than 8k, and the maximum dislocation at most k+1 . Our upper bounds are tight for compatible solutions, but possibly not tight for score solutions. It turns out that none of the two approaches is better than the other in all measures. For the problem of finding a minimum element, we first observe that there is no deterministic algorithm that guarantees to return one of the smallest k+ 1 elements. This implies that computing the first element of a score solution is optimum and we derive an algorithm that guarantees to find one of the k+ 2 smallest elements in time O(√(k)n) making O(√(k)n) comparisons, where n is the number of elements, and we generalize this algorithm to find all elements of score at most a given target t.

We study the minimum cut problem in the presence of uncertainty and show how to apply a novel robust optimization approach, which aims to exploit the similarity in subsequent graph measurements or similar graph instances, without posing any assumptions on the way they have been obtained. With experiments we show that the approach works well when compared to other approaches that are also oblivious towards the relationship between the input datasets.

We study the minimum cut problem in the presence of uncertainty and show how to apply a novel robust optimization approach, which aims to exploit the similarity in subsequent graph measurements or similar graph instances, without posing any assumptions on the way they have been obtained. With experiments we show that the approach works well when compared to other approaches that are also oblivious towards the relationship between the input datasets.