Reading for Tuesday, January 29: Chapter 3, especially through p. 48 (noting errata, as always) Understood my email broadcasts, and found the web site? HW1 questions or difficulties? (Due in ps to Tao by 5 p.m. Friday.) Model issues? Plenty, but bottom line: We've tried to give a definition that can accommodate all our algorithms. Our main main focus, though, will be on the algorithms themselves, except when we are proving *limitations* on ``such'' algorithms (where definition will be important). Today, let's focus on flooding, either as a way to broadcast, or as a way to build a spanning tree (that we will likely go on to *use* for broadcasting). Local summary of such broadcast: Forward what you hear to everyone you know (but only once). For spanning tree: Also remember from whom you first heard and who first heard from you (minor additional work). Lots of insightful observations useful and interesting, but a good top-down approach to verification is to list fairly easy observations/lemmas that are sufficient for the desired result. A draft at such a lemma list: 1. Switch parent at most once, from no one to some one (a neighbor). (Locally clear.) 2. Immediately *offer* to be parent of all other neighbors, and get back all acknowledgments (acceptances, rejections) within time 2 afterwards. (Locally clear.) 3. Within distance t of leader/root ==> get parent (and the broadcast message) within time t. (Easy induction, but calls for fudge at root.) 4. Everyone knows his ``children'' (those who have him as parent) within time 2 of his own parent selection. 5. No parent cycles. Note how useful our asynchronous ``time'' notion was! But is its delivery-time assumption *necessary* for our proof? (Carefully read the material on page 14.) Suppose we allow timed computations *without* the delivery bound. Can we show that even they have good outcomes? Yes--``normalize'' (and cite what we did prove). How do this ``normalization''? Transform an arbitrary admissible timed execution by scaling down delivery intervals in order of their starts in the sequence. But must argue that time remains unbounded: Clear if finitely many too-long deliveries--just consider the infinity of time after them all. If infinitely many, then each one in ``sequentially new'' territory adds 1 to time. Another question: When is it safe for the leader/root to start *using* the spanning tree? When all have ``terminated''? How know?? Approaches (likely pursued with care at some later time): 1. Postpone acknowledgment to parent until *get* acknowledgments from all other neighbors. (Complicates and perhaps slows things down.) 2. Go ahead *before* globally done, but take care not to allow ``passing''. ``Asynchronous pipelining''-- much like base runners.