Randomized Weighted Caching with Two Page Weights

Abstract. We consider a special case of the weighted caching problem where the weight of every page is either 1 or some fixed number M > 1 . We present a randomized algorithm which achieves a competitive ratio which is O( log k) where k is the number of pages which can fit in the cache.     

Another short proof of optimality for the MIN cache replacement algorithm

When a new item is written into a cache, an old item must be evicted; the latter can be chosen by the offline MIN algorithm, which was first proven to be optimal by Mattson et al. [R.L. Mattson, J. Gecsei, D.R. Slutz, I.L. Traiger, Evaluation techniques for storage hierarchies, IBM Systems J. 9 (2) (1970) 78-117]. Recently a new, short proof was given by van Roy [B. van Roy, A short proof of optimality for the MIN cache replacement algorithm, Inform. Process. Lett. 102 (2007) 72-73]; here we give another short proof using what we call an amortized simulation.     

Applying graphics hardware to achieve extremely fast geometric pattern matching in two and three dimensional transformation space

We present a GPU-based approach to geometric pattern matching. We reduce this problem to finding the depth (maximally covered point) of an arrangement of polytopes in transformation space and describe hardware assisted (GPU) algorithms which exploit the available set of graphics operations to perform a fast rasterized depth computation. We give two alternatives, one is for translation + scale and the other is for rigid transformations, both have 3-parameters transformation space. We give extensive experimental results showing the running time of our method and its dependence on various parameters.     

A Note on the Expected Time for Finding Maxima by List Algorithms

Maxima in R ^d are found incrementally by maintaining a linked list and comparing new elements against the linked list. If the elements are independent and uniformly distributed in the unit square [0,1] ^d , then, regardless of how the list is manipulated by an adversary, the expected time is O(n log ^d-2 n) . This should be contrasted with the fact that the expected number of maxima grows as log ^d-1 n , so no adversary can force an expected complexity of n log ^d-1 n . Note that the expected complexity is O(n) for d=2 . Conversely, there are list-manipulating adversaries for which the given bound is attained. However, if we naively add maxima to the list without changing the order, then the expected number of element comparisons is n +o(n) for any . In the paper we also derive new tail bounds and moment inequalities for the number of maxima. Received January 7, 1997; revised June 20, 1997.     

Probabilistic robust design with linear quadratic regulators

In this paper, we study robust design of uncertain systems in a probabilistic setting by means of linear quadratic regulators (LQR). We consider systems affected by random bounded nonlinear uncertainty so that classical optimization methods based on linear matrix inequalities cannot be used without conservatism. The approach followed here is a blend of randomization techniques for the uncertainty together with convex optimization for the controller parameters. In particular, we propose an iterative algorithm for designing a controller which is based upon subgradient iterations. At each step of the sequence, we first generate a random sample and then we perform a subgradient step for a convex constraint defined by the LQR problem. The main result of the paper is to prove that this iterative algorithm provides a controller which quadratically stabilizes the uncertain system with probability one in a finite number of steps. In addition, at a fixed step, we compute a lower bound of the probability that a quadratically stabilizing controller is found.     

The scenario approach for systems and control design

The ‘scenario approach’ is an innovative technology that has been introduced to solve convex optimization problems with an infinite number of constraints, a class of problems which often occurs when dealing with uncertainty. This technology relies on random sampling of constraints, and provides a powerful means for solving a variety of design problems in systems and control. The objective of this paper is to illustrate the scenario approach at a tutorial level, focusing mainly on algorithmic aspects. Its versatility and virtues will be pointed out through a number of examples in model reduction, robust and optimal control.     

An ellipsoid algorithm for probabilistic robust controller design

In this paper, a new iterative approach to probabilistic robust controller design is presented, which is applicable to any robust controller/filter design problem that can be represented as an LMI feasibility problem. Recently, a probabilistic Subgradient Iteration algorithm was proposed for solving LMIs. It transforms the initial feasibility problem to an equivalent convex optimization problem, which is subsequently solved by means of an iterative algorithm. While this algorithm always converges to a feasible solution in a finite number of iterations, it requires that the radius of a non-empty ball contained into the solution set is known a priori. This rather restrictive assumption is released in this paper, while retaining the convergence property. Given an initial ellipsoid that contains the solution set, the approach proposed here iteratively generates a sequence of ellipsoids with decreasing volumes, all containing the solution set. At each iteration a random uncertainty sample is generated with a specified probability density, which parameterizes an LMI. For this LMI the next minimum-volume ellipsoid that contains the solution set is computed. An upper bound on the maximum number of possible correction steps, that can be performed by the algorithm before finding a feasible solution, is derived. A method for finding an initial ellipsoid containing the solution set, which is necessary for initialization of the optimization, is also given. The proposed approach is illustrated on a real-life diesel actuator benchmark model with real parametric uncertainty, for which a robust state-feedback controller is designed.     

Resource-bounded measure on probabilistic classes

We extend Lutz's resource-bounded measure to probabilistic classes, and obtain notions of resource-bounded measure on probabilistic complexity classes such as BPE and BPEXP. Unlike former attempts, our resource bounded measure notions satisfy all three basic measure properties, that is every singleton {L} has measure zero, the whole space has measure one, and “enumerable infinite unions” of measure zero sets have measure zero.     

Guaranteed cost regulator design: A probabilistic solution and a randomized algorithm

This paper presents a gradient-based randomized algorithm to design a guaranteed cost regulator for a plant with general parametric uncertainties. The algorithm either provides with high confidence a probabilistic solution that satisfies the design specification with high probability for a randomly sampled uncertainty or claims that the feasible set of the design parameters is too small to contain a ball with a given radius. In both cases, the number of iterations executed in the algorithm is of polynomial order of the problem size and is independent of the dimension of the uncertainty.     

Enhanced algorithms for Local Search

Let G=(V,E) be a finite graph, and be any function. The Local Search problem consists in finding a local minimum of the function f on G, that is a vertex v such that f(v) is not larger than the value of f on the neighbors of v in G. In this note, we first prove a separation theorem slightly stronger than the one of Gilbert, Hutchinson and Tarjan for graphs of constant genus. This result allows us to enhance a previously known deterministic algorithm for Local Search with query complexity , so that we obtain a deterministic query complexity of , where n is the size of G, d is its maximum degree, and g is its genus. We also give a quantum version of our algorithm, whose query complexity is of . Our deterministic and quantum algorithms have query complexities respectively smaller than the algorithm Randomized Steepest Descent of Aldous and Quantum Steepest Descent of Aaronson for large classes of graphs, including graphs of bounded genus and planar graphs.     

Randomized OBDDs for the most significant bit of multiplication need exponential space

Integer multiplication as one of the basic arithmetic functions has been in the focus of several complexity theoretical investigations and ordered binary decision diagrams (OBDDs) are one of the most common dynamic data structures for Boolean functions. Only in 2008 the question whether the deterministic OBDD complexity of the most significant bit of integer multiplication is exponential has been answered affirmatively. Since probabilistic methods have turned out to be useful in almost all areas of computer science, one may ask whether randomization can help to represent the most significant bit of integer multiplication in smaller size. Here, it is proved that the randomized OBDD complexity is also exponential.     

Improved deterministic approximation algorithms for Max TSP

We present an O(n³)-time approximation algorithm for the maximum traveling salesman problem whose approximation ratio is asymptotically , where n is the number of vertices in the input complete edge-weighted (undirected) graph. We also present an O(n³)-time approximation algorithm for the metric case of the problem whose approximation ratio is asymptotically . Both algorithms improve on the previous bests.     

Efficient out-of-core sorting algorithms for the Parallel Disks Model

In this paper,¹ we present efficient algorithms for sorting on the Parallel Disks Model (PDM). Numerous asymptotically optimal algorithms have been proposed in the literature. However, many of these merge based algorithms have large underlying constants in the time bounds, because they suffer from the lack of read parallelism on the PDM. The irregular consumption of the runs during the merge affects the read parallelism and contributes to the increased sorting time. In this paper, we first introduce a novel idea called the dirty sequence accumulation that improves the read parallelism. Next, we show analytically that this idea can reduce the number of parallel I/O’s required to sort the input close to the lower bound of . We verify experimentally our dirty sequence idea with the standard R-Way merge and show that our idea can reduce the number of parallel I/Os to sort on the PDM significantly.     

An algorithm for partitioning trees augmented with sibling edges

We investigate a special case of the graph partitioning problem: the partitioning of a sibling graph which is an ordered tree augmented with edges connecting consecutive nodes that share a common parent. We describe the algorithm, XS, and present a proof of its correctness.     

Polynomial-time algorithms for probabilistic solutions of parameter-dependent linear matrix inequalities

A randomized approach is considered for a feasibility problem on a parameter-dependent linear matrix inequality (LMI). In particular, a gradient-based and an ellipsoid-based randomized algorithms are improved by introduction of a stopping rule. The improved algorithms stop after a bounded number of iterations and this bound is of polynomial order in the problem size. When the algorithms stop, either of the following two events occurs: (i) they find with high confidence a probabilistic solution, which satisfies the given LMI for most of the parameter values; (ii) they detect in an approximate sense the non-existence of a deterministic solution, which satisfies the given LMI for all the parameter values. These results are important because the original randomized algorithms have issues to be settled on detection of convergence, on the speed of convergence, and on the assumption of feasibility. The improved algorithms can be adapted for an optimization problem constrained by a parameter-dependent LMI. A numerical example shows the efficacy of the proposed algorithms.     

A note on the distribution of the number of prime factors of the integers

The Chernoff-Hoeffding bounds are fundamental probabilistic tools. An elementary approach is presented to obtain a Chernoff-type upper-tail bound for the number of prime factors of a random integer in {1,2,…,n}. The method illustrates tail bounds in negatively-correlated settings.     

An efficient parallel algorithm for building the separating tree

We present an efficient parallel algorithm for building the separating tree for a separable permutation. Our algorithm runs in O(log²n)$O\left({log}^{2}n\right)$ time using O(nlog^1.5n)$O\left(n{log}^{1.5}n\right)$ operations on the CREW PRAM and O(log²n)$O\left({log}^{2}n\right)$ time using O(nlognloglogn)$O(nlognloglogn)$ operations on the COMMON CRCW PRAM.     

An improved exact algorithm for the domatic number problem

The 3-domatic number problem asks whether a given graph can be partitioned into three dominating sets. We prove that this problem can be solved by a deterministic algorithm in time n^2.695 (up to polynomial factors) and in polynomial space. This result improves the previous bound of n^2.8805, which is due to Björklund and Husfeldt. To prove our result, we combine an algorithm by Fomin et al. with Yamamoto's algorithm for the satisfiability problem. In addition, we show that the 3-domatic number problem can be solved for graphs G with bounded maximum degree Δ(G) by a randomized polynomial-space algorithm, whose running time is better than the previous bound due to Riege and Rothe whenever Δ(G)?5. Our new randomized algorithm employs Schöning's approach to constraint satisfaction problems.