A simple proof of the uniform consensus synchronous lower bound

We give a simple and intuitive proof of an f+2 round lower bound for uniform consensus. That is, we show that for every uniform consensus algorithm tolerating t failures, and for every f?t−2, there is an execution with f failures that requires f+2 rounds.     

Strongly Terminating Early-Stopping k-Set Agreement in Synchronous Systems with General Omission Failures

The k-set agreement problem is a generalization of the consensus problem: considering a system made up of n processes where each process proposes a value, each non-faulty process has to decide a value such that a decided value is a proposed value, and no more than k different values are decided. It has recently be shown that, in the crash failure model, $\min(\lfloor \frac{f}{k}\rfloor+2,\lfloor \frac{t}{k}\rfloor +1)The k-set agreement problem is a generalization of the consensus problem: considering a system made up of n processes where each process proposes a value, each non-faulty process has to decide a value such that a decided value is a proposed value, and no more than k different values are decided. It has recently be shown that, in the crash failure model, min(?\fracfk?+2,?\fractk?+1)\min(\lfloor \frac{f}{k}\rfloor+2,\lfloor \frac{t}{k}\rfloor +1) is a lower bound on the number of rounds for the non-faulty processes to decide (where t is an upper bound on the number of process crashes, and f, 0≤f≤t, the actual number of crashes).     

A note on the k-Canadian Traveller Problem

We consider the online problem k-CTP, which is the problem to guide a vehicle from some site s to some site t on a road map given by a graph G=(V,E) in which up to k (unknown) edges are blocked by avalanches. An online algorithm learns from a blocked edge when reaching one of its endpoints. Thus, it might have to change its route to the target t up to k times. We show that no deterministic online algorithm can achieve a competitive ratio smaller than 2k+1 and give an easy algorithm which matches this lower bound. Furthermore, we show that randomization can not improve the competitive ratio substantially, by establishing a lower bound of k+1 for the competitivity of randomized online algorithms against an oblivious adversary.     

Computing Sparse Multiples of Polynomials

We consider the problem of finding a sparse multiple of a polynomial. Given f??F[x] of degree d over a field F, and a desired sparsity t, our goal is to determine if there exists a multiple h??F[x] of f such that h has at most t non-zero terms, and if so, to find such an h. When F=? and t is constant, we give an algorithm which requires polynomial-time in d and the size of coefficients in h. When F is a finite field, we show that the problem is at least as hard as determining the multiplicative order of elements in an extension field of F (a problem thought to have complexity similar to that of factoring integers), and this lower bound is tight when t=2.     

The inherent price of indulgence

An indulgent algorithm is a distributed algorithm that tolerates asynchronous periods of the network when process crash detection is unreliable. This paper presents a tight bound on the time complexity of indulgent consensus algorithms. We consider a round-based eventually synchronous model, and we show that any t-resilient consensus algorithm in this model, requires at least t+2 rounds for a global decision even in runs that are synchronous. We contrast our lower bound with the well-known t+1 round tight bound on consensus in the synchronous model. We then prove the bound to be tight by exhibiting a new t-resilient consensus algorithm in the eventually synchronous model that reaches a global decision at round t+2 in every synchronous run. Our new algorithm is in this sense significantly faster than the most efficient indulgent algorithm we know of, which requires 2t+2 rounds in synchronous runs. Our lower bound applies to round-based consensus algorithms with unreliable failure detectors such as ⋄ P and ⋄ S, and our matching algorithm can be adapted to such failure detectors. This work is partially supported by the Swiss National Science Foundation (project number 510-207).     

Message and time efficient consensus protocols for synchronous distributed systems

For a synchronous distributed system of n processes with up to t potential and f   actual crash failures, where (t<n-1,f≤t)$(t<n-1,f\le t)$, the time lower bound for a protocol to achieve consensus is min(t+1,f+2)$\min (t+1,f+2)$ rounds. Currently, most researches in this field focus on the time efficiency of consensus protocols. This paper proposes consensus protocols for synchronous distributed systems that achieve both message and time   efficiency. Based on an early stopping consensus protocol for synchronous distributed system with crash failures, we propose a rotating coordinator scheme that significantly reduces message complexity. However, this protocol is not time efficient because it requires min(t+1,f+3)$\min (t+1,f+3)$ rounds to reach consensus. Thus, to achieve both time and message efficiency, we propose another protocol in which (t+1)$(t+1)$ coordinators are used to send messages in each round. Furthermore, we show that the proposed consensus protocol with crash failures can be revised to be more message-efficient with orderly crash failures. When a process is able to send more than one message to another in a round, we propose an optimal message efficient early stopping consensus protocol for synchronous distributed systems with orderly crash failures.     

Adaptive timeliness of consensus in presence of crash and timing faults

The Δ$\mathrm{\Delta }$-timed uniform consensus is a stronger variant of the traditional consensus and it satisfies the following additional property: every correct process terminates its execution within a constant time Δ$\mathrm{\Delta }$ (Δ$\mathrm{\Delta }$-timeliness), and no two processes decide differently (uniformity). In this paper, we consider the Δ$\mathrm{\Delta }$-timed uniform consensus problem in presence of _fc$f_{\mathrm{c}}$ crash processes and _ft$f_{\mathrm{t}}$ timing-faulty processes, and propose a Δ$\mathrm{\Delta }$-timed uniform consensus algorithm. The proposed algorithm is adaptive in the following sense: it solves the Δ$\mathrm{\Delta }$-timed uniform consensus when at least _ft+1$f_{\mathrm{t}}+1$ correct processes exist in the system. If the system has less than _ft+1$f_{\mathrm{t}}+1$ correct processes, the algorithm cannot solve the Δ$\mathrm{\Delta }$-timed uniform consensus. However, as long as _ft+1$f_{\mathrm{t}}+1$ processes are non-crashed, the algorithm solves (non-timed) uniform consensus. We also investigate the maximum number of faulty processes that can be tolerated. We show that any Δ$\mathrm{\Delta }$-timed uniform consensus algorithm tolerating up to _ft$f_{\mathrm{t}}$ timing-faulty processes requires that the system has at least _ft+1$f_{\mathrm{t}}+1$ correct processes. This impossibility result implies that the proposed algorithm attains the maximum resilience about the number of faulty processes. We also show that any Δ$\mathrm{\Delta }$-timed uniform consensus algorithm tolerating up to _ft$f_{\mathrm{t}}$ timing-faulty processes cannot solve the (non-timed) uniform consensus when the system has less than _ft+1$f_{\mathrm{t}}+1$ non-crashed processes. This impossibility result implies that our algorithm attains the maximum adaptiveness.     

Narrowing power vs efficiency in synchronous set agreement: Relationship, algorithms and lower bound

The k-set agreement problem is a generalization of the uniform consensus problem: each process proposes a value, and each non-faulty process has to decide a value such that a decided value is a proposed value, and at most k different values are decided. It has been shown that any algorithm that solves the k-set agreement problem in synchronous systems that can suffer up to t crash failures requires rounds in the worst case. It has also been shown that it is possible to design early deciding algorithms where no process decides and halts after rounds, where f is the number of actual crashes in a run (0≤f≤t).This paper explores a new direction to solve the k-set agreement problem in a synchronous system. It considers that the system is enriched with base objects (denoted has [m,?]_SA objects) that allow solving the ?-set agreement problem in a set of m processes (m<n). The paper makes several contributions. It first proposes a synchronous k-set agreement algorithm that benefits from such underlying base objects. This algorithm requires rounds, more precisely, rounds, where . The paper then shows that this bound, that involves all the parameters that characterize both the problem (k) and its environment (t, m and ?), is a lower bound. The proof of this lower bound sheds additional light on the deep connection between synchronous efficiency and asynchronous computability. Finally, the paper extends its investigation to the early deciding case. It presents a k-set agreement algorithm that directs the processes to decide and stop by round . These bounds generalize the bounds previously established for solving the k-set agreement problem in pure synchronous systems.     

The possible resolution of Boltzmann brains problem in phantom cosmology

We consider the well-known Boltzmann brains problem in the framework of simple phantom energy models with little rip and big rip singularities. It is shown that these models (i) satisfy the observational data and (ii) may be free from the Boltzmann brains problem. Human observers in phantom models can exist only during a certain period t < t _f (t _f is the lifetime of the universe) via the Bekenstein bound. If the fraction of unordered observers in this part of the universe history is negligible as comparison with ordered observers, than the Boltzmann brains problem does not appear. The bounds on model parameters derived from such a requirement do not contradict to the allowable range according to the observational data.     

Communication-Efficient Broadcasting in Complete Networks with Dynamic Faults

We consider the problem of message (and bit) efficient broadcasting in complete networks with dynamic faults. Despite the simplicity of the setting, the problem turned out to be surprisingly interesting from the algorithmic point of view. In this paper we show an Ω(n + t f ^{t/(t – 1)}) lower bound on the number of messages sent by any t-step broadcasting algorithm, where f is the number of faults per step. The core of the paper contains a constructive O(n + t f ^{(t + 1)/t} ) upper bound. The algorithms involved are of time complexity O(t), not strictly t. In addition, we present a bit-efficient algorithm of O(n log² n) bit and O(log n) time complexities. We also show that it is possible to achieve the same message complexity even if the nodes do not know the id’s of their neighbours, but instead have only a Weak Sense of Direction.     

Scalable and leaderless Byzantine consensus in cloud computing environments

Traditional Byzantine consensus in distributed systems requires n ≥ 3f + 1, where n is the number of nodes. In this paper, we present a scalable and leaderless Byzantine consensus implementation based on gossip, requiring only n ≥ 2f + 1 nodes. Unlike conventional distributed systems, the network topology of cloud computing systems is often not fully connected, but loosely coupled and layered. Hence, we revisit the Byzantine consensus problem in cloud computing environments, in which each node maintains some number of neighbors, called local view. The message complexity of our Byzantine consensus scheme is O(n), instead of O(n ²). Experimental results and correctness proof show that our Byzantine consensus scheme can solve the Byzantine consensus problem safely in a scalable way without a bottleneck and a leader in cloud computing environments.     

Continuous consensus with ambiguous failures

Continuous consensus (CC) is the problem of maintaining up-to-date and identical copies of a “core” of information about the past at all correct processes in the system (Mizrahi and Moses, 2008 [6]). This is a primitive that supports simultaneous coordination among processes, and eliminates the need for issuing separate instances of consensus for different tasks. Recent work has presented new simple and efficient optimum protocols for continuous consensus in the crash and (sending) omissions failure models. For every pattern of failures, these protocols maintain at each and every time point a core that subsumes that maintained by any other continuous consensus protocol. This paper considers the continuous consensus problem in the face of harsher failures: general omissions and authenticated Byzantine failures. Computationally efficient optimum protocols for CC do not exist in these models if $P\ne NP$. A variety of CC protocols are presented. The first is a simple protocol that enters every interesting event into the core within $t+1$ rounds (where $t$ is the bound on the number of failures), provided there are a majority of correct processes. The second is a protocol that achieves similar performance so long as $n>t$ (i.e., there is always guaranteed to be at least one correct process). The final protocol makes use of active failure monitoring and failure detection to include events in the core much faster in many runs of interest. Its performance is established based on a nontrivial property of minimal vertex covers in undirected graphs. The results are adapted to the authenticated Byzantine failure model, in which it is assumed that faulty processes are malicious, but correct processes have unforgeable signatures. Finally, the problem of uniform CC is considered. It is shown that a straightforward version of uniform CC is not solvable in the setting under study. A weaker form of uniform CC is defined, and protocols achieving it are presented.     

The impossibility of boosting distributed service resilience

We study f-resilient services, which are guaranteed to operate as long as no more than f of the associated processes fail. We prove three theorems asserting the impossibility of boosting the resilience of such services. Our first theorem allows any connection pattern between processes and services but assumes these services to be atomic (linearizable) objects. This theorem says that no distributed system in which processes coordinate using f-resilient atomic objects and reliable registers can solve the consensus problem in the presence of f+1 undetectable process stopping failures. In contrast, we show that it is possible to boost the resilience of some systems solving problems easier than consensus: for example, the 2-set-consensus problem is solvable for 2n processes and 2n-1 failures (i.e., wait-free) using n-process consensus services resilient to n-1 failures (wait-free). Our proof is short and self-contained.We then introduce the larger class of failure-oblivious services. These are services that cannot use information about failures, although they may behave more flexibly than atomic objects. An example of such a service is totally ordered broadcast. Our second theorem generalizes the first theorem and its proof to failure-oblivious services.Our third theorem allows the system to contain failure-aware services, such as failure detectors, in addition to failure-oblivious services. This theorem requires that each failure-aware service be connected to all processes; thus, f+1 process failures overall can disable all the failure-aware services. In contrast, it is possible to boost the resilience of a system solving consensus using failure-aware services if arbitrary connection patterns between processes and services are allowed: consensus is solvable for any number of failures using only 1-resilient 2-process perfect failure detectors.As far as we know, this is the first time a unified framework has been used to describe both atomic and non-atomic objects, and the first time boosting analysis has been performed for services more general than atomic objects.     

Fast method to compute the scalar product of gradient and given vector

The paper deals with a special problem in Automatic Differentiation. Letf be a rational function ofn variables, let #(f) denote the number of operations to evaluatef(x), letg denote the gradient off. Many algorithms for minimizingf(x) require the scalar productg(u) ^tv. In the standard method for computingg(u) ^tv the amount of work grows withn·#(f). In this note a new method for computingg(u) ^tv is presented. The new method is considerably faster, its amount of work only grows with #(f).     

Is Submodularity Testable?

We initiate the study of property testing of submodularity on the boolean hypercube. Submodular functions come up in a variety of applications in combinatorial optimization. For a vast range of algorithms, the existence of an oracle to a submodular function is assumed. But how does one check if this oracle indeed represents a submodular function? Consider a function f:{0,1} ⁿ →?. The distance to submodularity is the minimum fraction of values of f that need to be modified to make f submodular. If this distance is more than ?>0, then we say that f is ?-far from being submodular. The aim is to have an efficient procedure that, given input f that is ?-far from being submodular, certifies that f is not submodular. We analyze a natural tester for this problem, and prove that it runs in subexponential time. This gives the first non-trivial tester for submodularity. On the other hand, we prove an interesting lower bound (that is, unfortunately, quite far from the upper bound) suggesting that this tester cannot be efficient in terms of ?. This involves non-trivial examples of functions which are far from submodular and yet do not exhibit too many local violations. We also provide some constructions indicating the difficulty in designing a tester for submodularity. We construct a partial function defined on exponentially many points that cannot be extended to a submodular function, but any strict subset of these values can be extended to a submodular function.     

The number of pessimistic guesses in Generalized Mastermind

Mastermind is a famous two-player game, where the codemaker has to choose a secret code and the codebreaker has to guess it in as few questions as possible. The code consists of 4 pegs, each of which is one of 6 colors. In Generalized Mastermind a general number p of pegs and a general number c of colors is considered. Let f(p,c) be the pessimistic number of questions for the generalization of Mastermind with an arbitrary number p of pegs and c of colors. By a computer program we compute ten new values of f(p,c). Combining this program with theoretical methods, we compute all values f(3,c) and a tight lower and upper bound for f(4,c). For f(p,2) we give an upper bound and a lower bound. Finally, combining results for fixed p and c, we give bounds for the general case f(p,c).     

Curve generation of implicit functions by incremental computers

The conventional numerical solution of an implicit function f(x, y) = 0 is substantially complicated for calculating by any computer. We propose a new method representing the argument of the implicit function as a unary function of a parameter, t, if the continuous and unique solution of f(x, y) = 0 exists. The total differential $\text{d}\text{f}\text{d}\text{t}$ constitutes simultaneous differential equations of which the solution about x and y is unique. The Newton-Raphson method must be used to calculate the values near singular points of an implicit function and then the sign of dt has to be decided according to four special cases. Incremental computers are suitable for curve generation of implicit functions by the new method, because the incremental computer can perform more complex algorithms than the analog computer and can calculate faster than the digital computer. This method is easily applicable to curve generation in three-dimensional space.     

Conditions for Set Agreement with an Application to Synchronous Systems

The k-set agreement problem is a generalization of the consensus problem:considering a system made up of n processes where each process proposes a value,each non-faulty process has to decide a value such that a decided value is a proposed value,and no more than k different values are decided.While this problem cannot be solved in an asynchronous system prone to t process crashes when t≥k,it can always be solved in a synchronous system;(?)+1 is then a lower bound on the number of rounds(consecutive commun...     

Optimal output-transitions for linear systems

This article addresses the optimal (minimum-input-energy) output-transition problem for linear systems. The goal is to transfer the output from an initial value (for all time t?t_i) to a final output value (for all time t?t_f). Previous methods solve this output-transition problem by transforming it into a state-transition problem; the initial and final states (x(t_i),x(t_f), respectively) are chosen and a minimum-energy state-to-state transition problem is solved. However, the choice of the initial and final states can be ad hoc and the resulting output-transition cost (input energy) may not be minimal. The contribution of this article is the solution of the optimal output-transition problem. An example system with elastic dynamics is studied to illustrate the proposed method. Simulation results are presented that show substantial reduction of transition costs with the use of the proposed method when compared to the use of minimum-energy state-to-state transitions.     

Note on Max Lin-2 above Average

In the Max Lin-2 problem we are given a system S of m linear equations in n variables over F₂ in which equation j is assigned a positive integral weight wj for each j. We wish to find an assignment of values to the variables which maximizes the total weight of satisfied equations. This problem generalizes Max Cut. The expected weight of satisfied equations is W/2, where W=w₁+?+wm; W/2 is a tight lower bound on the optimal solution of Max Lin-2.Mahajan et al. (Parameterizing above or below guaranteed values, J. Comput. Syst. Sci. 75 (2009) 137-153) stated the following parameterized version of Max Lin-2: decide whether there is an assignment of values to the variables that satisfies equations of total weight at least W/2+k, where k is the parameter. They asked whether this parameterized problem is fixed-parameter tractable, i.e., can be solved in time f(k)(nm)^O(1), where f(k) is an arbitrary computable function in k only. Their question remains open, but using some probabilistic inequalities and, in one case, a Fourier analysis inequality, Gutin et al. (A probabilistic approach to problems parameterized above tight lower bound, in: Proc. IWPEC'09, in: Lect. Notes Comput. Sci., vol. 5917, 2009, pp. 234-245) proved that the problem is fixed-parameter tractable in three special cases.In this paper we significantly extend two of the three special cases using only tools from combinatorics. We show that one of our results can be used to obtain a combinatorial proof that another problem from Mahajan et al. (Parameterizing above or below guaranteed values, J. Comput. Syst. Sci. 75 (2009) 137-153), Max r-SAT above Average, is fixed-parameter tractable for each r?2. Note that Max r-SAT above Average has been already shown to be fixed-parameter tractable by Alon et al. (Solving MAX-r-SAT above a tight lower bound, in: Proc. SODA 2010, pp. 511-517), but the paper used the approach of Gutin et al. (A probabilistic approach to problems parameterized above tight lower bound, in: Proc. IWPEC'09, in: Lect. Notes Comput. Sci., vol. 5917, 2009, pp. 234-245).