This document summarizes key points about consensus agreement algorithms. It discusses how consensus can be solved with halting (crash) failures in synchronous systems using a simple algorithm that requires f+1 rounds, where f is the maximum number of failures. It also proves that no consensus algorithm can solve the problem in less than f+1 rounds. For asynchronous systems, the document notes that even one halting failure makes consensus insolvable. Byzantine agreement is also impossible to solve in asynchronous systems.

1. SLIDES BY OSAMA ASKOURA
EECS 6117
Distributed Computing
Set3

2. Consensus Agreement

3. Slide
2
Imagine a Byzantine agreement problem
where processes cannot be malicious (lie or
cheat or behave inconsistently)
Instead, processes can only behave
consistently or die (fail.)
This is what we define as a consensus
agreement with halting failures
Consensus in
Model
Synchronous
Non Anonymous Processes
Message-Passing system

4. Slide
2
Consensus algorithm 1:
• Pref : v (your input)
• Round 1: send your input to all
• Round 2:
for i =1 to f+1
• Keep sending input to all
• Pref =max value received in round
• Output pref
This means that we can tolerate any number
of failures (unlike Byzantine), but we need f+1
rounds!
Model
Synchronous
Non Anonymous Processes
Message-Passing system

5. Slide
2
CLAIM:
We cannot solve consensus in less than f+1 rounds
PROOF (Contradiction):
Suppose, exists algorithm that uses < f+ 1 rounds
Ifα1 and α2 are 2 executions of the algorithm,
α1 ~ α2 means some correct processes get same sequence of
messages in both executions
Ifα1 ~ α2 then some processes will output same result in both
executions
α1 ~~α2 if α1 ~ β1 ~ β2 ~ βn ~α2
Ifα1 ~~ α2 then they have same output.
Model
Synchronous
Non Anonymous Processes
Message-Passing system

6. Proof (continued):
Let α1 be failure-free execution where p1..pi have input 0 and
pi+1….. Pn have input 1
Inputs
P1 P2 P3 P4 …. Pn
α0 1 1 1 1 ….. 1 Outputs 1
α1 0 1 1 1 ….. 1
α2 0 0 1 1 ….. 1
α3 0 0 0 1 ….. 1
α4 0 0 0 0 ….. 1
αn 0 0 0 0 ….. 0 Outputs 0

7. Slide
2
PROOF (continued):
To contradict, prove:
α0 (no failure) ~β1 ~ α1  no failure
We know that α0 outputs 0 and αn outputs 1.
We will show that for each I αi ~~ αi+1 up to αn, so proc will
Output same result in α0 and αn;but we know they don’t!
(Contradiction)
Model
Synchronous
Non Anonymous Processes
Message-Passing system
Proc 1 fails
immediately

8. Slide
2
PROOF (continued):
Lemma:
Suppose ψ is an execution with ≤ 1failure per round (failure-sparse)
And is same as execution γ up to end of first r rounds and ψ has
No failures in round r+1 or later. ( 0 ≤r≤f )
Then ψ ~~ γ
Model
Synchronous
Non Anonymous Processes
Message-Passing system

9. Slide
2
PROOF (continued):
Proof of Lemma (By reverse induction on r):
Base step: r = f
Then ψ &γ are identical in first f rounds,
Since the algorithm uses f rounds (ψ ~~γ)
Inductive step
Assume claim is true for r+1; Prove claim for r
If γhas no failures in round r+1, then (ψ ~~γ) by inductive
hypothesis
We use fact that r ≥ f+1 when we kill q.
Model
Synchronous
Non Anonymous Processes
Message-Passing system

10. Summary for Synchronous
Conensus & Byzantine

11. Slide
2
Byzantine agreement is solvable iff n > 3f and
connectivity > 2f in an arbitrary graph
Halting failures (Consensus) is solvable iff connectivity >
f in an arbitrary graph and must take f + 1 rounds

12. How About
Byzantine/Consensus in
Asynchronous systems?

13. Slide
2
In Asynchronous systems,
1 halting failure makes the problem of agreement
insolvable. This is remains true even if you solve the
Halting Problem.
Impossibility for halting failures implies impossibility
for Byzantine failures as well in asynchronous systems

14. Slide
18
EECS6117notesFW15-16,Instructor:EricRuppert
HagitAttiyaandJenniferWelch.DistributedComputing:Fundamentals,SimulationsandAdvanced
Topics,2ndedition. Wiley,2004.
NancyA.Lynch.DistributedAlgorithms. MorganKaufmann,1996.
References