Outline

• Analysis of Asynchronous CCP
• In-Class Exercise
• The Byzantine Agreement Problem

Asynchronous-CCP

Input: Registers C[0] and C[1] initialized to (0,0).
Output: Exactly one of the two registers has value #.
0. P[i] is initially scanning a randomly chosen register. 
   Thereafter, it changes its current register at the end of each iteration. 
   The local variables T[i] and B[i] are initialized to 0.
1. P[i] obtains a lock on the current register and reads (t[i],R[i]).
2. P[i] selects one of five cases:
   (a) case [R[i] = #]: halt;
   (b) case [T[i] < t[i]]: set T[i] = t[i] and B[i] = R[i]
   (c) case [T[i] > t[i]]: write # into the current register and halt;
   (d) case [T[i] = t[i], R[i] = 0, B[i] = 1]: 
       write # into the current register and halt
   (e) case [otherwise]: Set T[i] = T[i] + 1 and t[i] = t[i] + 1, 
       assign a random bit-value to B[i] , 
       and write (t[i] , B[i]) to the current register.
3. P[i] releases the lock on its current register, 
   moves to the other register, and returns to Step 1.

Analysis of Asynchronous-CCP

Theorem. For any `c gt 0`, Asynchronous-CPP has total cost in operations executed exceeding `c` with probability at most `2^(-Omega(c))`.

Proof. The main difference between this and the synchronous case is in Step 2 (b) and 2 (c):

• Case 2(b) is supposed to handle where the processor is playing catch up with the other processor.
• Case 2(c) handles where the processor is ahead of the other processor.

To prove correctness of the protocol, we consider the two cases (2(c), 2(d)) where a processor can write a # to its current cell. At the end of an iteration, a processor's timestamp `T[i]` will equal the timestamp of the current register `t[i]`. Further # cannot be written in the first iteration by either processor. (Proof cont'd next slide).

Proof cont'd

Suppose `P[i]` has just entered case 2(c), with some timestamp `T^star[i]`, and its current cell is `C[i]` with timestamp `t^star[i] lt T[i]^star`. The only possible problem is that `P[1-i]` might write `#` into register `C[1-i]` . Suppose this error occurs, and let `t^star[1-i]` and `T^star[1-i]` be the timestamp during the iteration for the other processor.

As `P[i]` comes to `C[i]` with a timestamp of `T^star[i]` , it must have left `C[1-i]` with a timestamp before `P[1-i]` could write `#` into it. Since timestamps don't decrease `t^star[1-i] ge T^star[i]`. Further `P[1-i]` cannot have its timestamp `T^star[1-i]` exceed `t^star[i]` since it must go to `C[1-i]` from `C[i]` and the timestamp of that register never exceeds `t^star[i]`. So we have `T^star[1-i] le t^star[i] lt T^star[i] le t^star[1-i]`. This means `P[1-i]` must enter case 2(b) as `T^star[1-i] lt t^star[1-i]`. This contradicts it being able to write a #.

We can analyze the case P[i] has just entered case 2(d) in a similar way, except we would reach the conclusion that `T[1-i] le t^star[i] = T[i] le t^star[1-i]` and so it is possible that `T[1-i] = t^star[1-i]`. But if this event happens, we are in the synchronous situation so our earlier correctness argument works. Thus, we have established correctness of the algorithm.

Runtime of Asynchronous-CCP

• We now just need to analyze the runtime of our above algorithm.
• The cost is proportional to the largest timestamp.
• Only case 2(e) increase the timestamp of a register, and this only happens if case 2(d) does not apply.
• Furthermore, the processor that raises the timestamp must have its current `B[i]` value chosen during a visit to the other register. So the analysis of the synchronous case applies.

In-Class Exercise

• Organize into groups of two.
• Each person in the group get out a sheet of paper and a coin.
• Have one other sheet of paper for the choice registers C[i].
• Each person play the role of a processor and keep track of variable states and changes to states on the papers.
• Perform a live simulation of the Async-CPP protocol.
• When done, post the transcripts recorded on the three sheets of paper to the Mar 6 In-Class Exercise Thread.

Byzantine Agreement Problem

• The problem was introduced by Pease, Shostak, and Lamport in 1980.
• It is similar to the Choice Coordination Problem.
• The original name of the problem was the Byzantine Generals Problem and it was supposed we have `n` Byzantine Generals that have to agree on a battle plan.
• In our set-up, we want to agree on one of two possible values (say, heads or tails `[0,1]`).
• We have `n` processors `t` of which may be faulty.
• We require that the decision reached by a protocol should have:
  1. All good processors finish with the same decision.
  2. If all the good processors begin with the same value `v`, then they should all finish with same value `v`.

More on the Set-up of the Byzantine Problem

• The set of faulty processors is fixed before the computation begins.
• The good processors do not know which processors are faulty.
• During a round, each processor may send one message to each other processor.
• Each processor receives a vote from each of the remaining processors before the following round begins.
• A processor is allowed to send different messages to different processors.
• Good processors will be assumed to follow our algorithm exactly.
• It is known any deterministic algorithm for this problem needs at least `t+1` rounds.
• We will present a randomized algorithm with `O(1)` expected runtime.

Some More Remarks before we Begin

• Our solution to the choice coordination problem was only for two processors choosing between two values.
• Neither of these processors was faulty.
• The algorithm we present today works for `n` processors choosing between two values, so is already more general, ignoring the allowance for faulty processors.
• The original choice coordination problem was for `n` processors to choose among `m` choices.
• Notice by repeating the Byzantine procedure `log_2 m` times we can have our processors agree on a first bit of the number between `1` to `m`, then a second bit of the number between `1` to `m`, etc.
• If each such single bit agreement can be done in constant time as a function of `n`, then agreeing on a number between 1 and `m` can be done in `O(log m)` time. Notice this does not depend on the number of processors.