Next reading: Start Chapter 4 (noting errata, as always) Note my objection to the text's versions of the lower bounds: Must structure the states and have a formal notion of uid. In fact the results are broader and simpler than this. Moreover, for *non*leaders, the lower bounds don't even require termination. We rule out even solutions that guarantee, in each admissible execution, only that exactly one processor eventually claims leadership. Now back to the remaining two *synchronous* lower bounds: How get synchronous lower bounds? Go back to the ``symmetry'' approach. Roughly: *If* we have enough symmetry, then there must be Omega(n) ``active'' rounds (i.e., involving msgs.) (by symmetry of election declaration) and Omega(n/k) msgs. sent in active round k (by symmetry of msg. transmission). Therefore, total is Omega(n (1/Omega(n) + 1/1less + 1/2less + ...)) = Omega(n log n). How guarantee enough symmetry? Restrict to ``comparison based'', and design rings with many neighborhoods of same order type. Note why ``comparison based'' (a) is inevitably a misnomer, (b) requires definition. (We neither know nor can restrict ``instructions'' by the state machines. All we have are transition functions.) Perhaps better name: ``order determined'' Whatever we call it, the criterion is: whole rings order-equivalent ==> ``behaviors'' the same for corresponding (i.e., ``matching'') processors. ``behavior'': When to communicate in each direction, and when to declare self leader. (Certainly all this would be *implied* by any *instruction-level* definition of ``comparison based.'') Remarks: (i) We *don't* include *what* to communicate in ``behavior.'' The lower bound holds even if we always provide a full ``dump.'' (ii) The underlying processor order can be by uid (most likely), by index, or anything else. Lemma: For each n, there is a ring ``S_n'' that has ``nice symmetry properties.'' Proof: We do it only for n a power of 2, in which case we take S_n to be R_n^rev. And we relegate the proof to HW2 (Exercise 3.9). Theorem: Exists d, forall A, n, C of size at least 2n, *if* synchronous algorithm A correctly elects unique leaders in rings of size n over uid space C, *and* the behavior of each processor is order-determined, *then* the execution of A on any ring with the same order type as S_n generates at least dn log n msgs. by the time the leader is elected. (Think about degeneracies: card(C) < n, card(C) = n, card(C) = n + 1.) Proof: Follow the plan given above. For n power of 2, it works out exactly as planned. For other n, it is harder to come up with good S_n. But can succeed if look only at nbhds. at least sqrt(n) in size and loosen up on their number by a constant factor. One subtlety/needed lemma: Behavior determined by whole order type ==> current behavior determined by order type of what could have been seen so far (based on distance), at least within the S_n lookalike involving the n smallest uid's. Reason: Any two such neighborhoods *could* alternatively be completed to a complete size-n ring of the same order type, by using large unused uid's (of which there are plenty, by hypothesis). Finally, how suffice with just a time bound t(n) (and not order determinism)? *Corollary*, ... based on Ramsey's theorem! Given A and n, find a big enough (i.e., 2n) *sub*universe of uid's (or even indices!) on which A's behavior *is* order determined, and build an S_n lookalike there. How a job for Ramsey's theorem? Looking for subuniverse of size 2n, all of whose size-n subsets are treated same by A. Number of ``treatments'' (Ramsey's ``colors'') is bounded if we assume A needs only t(n) rounds. (An easy bound: 2 raised to the power 3ntn!.) Ramsey: Such subuniverse does exist, provided original was big enough in terms of the 3 parameters. (It certainly was, since it was infinite.)