Quickly Avoiding a Random Catastrophe
Stav Ashur, Sariel Har-Peled
TL;DR
This paper addresses how to simulate a Las Vegas randomized algorithm with unknown running-time distribution by TTL-based stop-and-restart schemes, aiming for an expected running time close to the optimal. It revisits and extends the classic TTL framework of Luby et al., introducing a spectrum of strategies including random TTLs (notably the $\zeta(2)$ distribution), counter-based TTL sequences, wide-speed parallelism, and caching via pause-resume. The key contributions are formal analyses and proofs showing these strategies achieve $O(\mathcal{O} \log \mathcal{O})$ expected time under broad conditions, as well as practical considerations for parallelism and cache sizing. The findings illuminate how carefully designed restart and scheduling policies can dramatically improve the time to obtain a successful run, with strong implications for randomized solvers and search problems where the underlying distribution is unknown. Overall, the work broadens the toolkit for optimal or near-optimal simulation of Las Vegas algorithms and highlights parallelism as a powerful lever for performance gains.
Abstract
We study the problem of constructing simulations of a given randomized search algorithm \texttt{alg} with expected running time $O( \mathcal{O} \log \mathcal{O})$, where $\mathcal{O}$ is the optimal expected running time of any such simulation. Counterintuitively, these simulators can be dramatically faster than the original algorithm in getting alg to perform a single successful run, and this is done without any knowledge about alg, its running time distribution, etc. For example, consider an algorithm that randomly picks some integer $t$ according to some distribution over the integers, and runs for $t$ seconds. then with probability $1/2$ it stops, or else runs forever (i.e., a catastrophe). The simulators described here, for this case, all terminate in constant expected time, with exponentially decaying distribution on the running time of the simulation. Luby et al. studied this problem before -- and our main contribution is in offering several additional simulation strategies to the one they describe. In particular, one of our (optimal) simulation strategies is strikingly simple: Randomly pick an integer $t>0$ with probability $c/t^2$ (with $c= 6/π^2$). Run the algorithm for $t$ seconds. If the run of alg terminates before this threshold is met, the simulation succeeded and it exits. Otherwise, the simulator repeat the process till success.