Introduction to the Gödel Prize Session

1. Introduction to the Gödel Prize Session Sergio Rajsbaum Math Institute UNAM, Mexico

2. The Gödel Prize • For outstanding papers in theoretical CS • Sponsored jointly by EATCS and ACM-SIGACT • Presented annually since 1993 • (alternately in ICALP and STOC) • To journal paper(s) published in the past 7 years • Past winners related to distributed computing: • 2000: M. Vardi, P. Wolper about logic for concurrency • 1997: J. Halpern, Y. Moses about knowledge

3. 2004 Gödel Prize [HS] Maurice Herlihy, Nir Shavit JACM 1999 Mike Saks, Fotios Zaharoglou SICOMP 2000 [SZ]

4. 2004 Gödel Prize • Both conference versions in STOC 1993 • And a third one with the same result, but not published in a journal: Liz Borowsky, Eli Gafni [BG]

5. The importance of the papers in a nutshell • Lamport’s “Time, Clocks,…” paper is perhaps the first and most fundamental in distributed computing • 1st Dijkstra prize • An execution is actually a partial order • Different total orders are indistinguishable • A connection with special relativity The approach discovered by these paper show how to paste together multiple executions • Inherent connection with topology

6. The Results

7. The result in common to the three papers • Wait-free: solving the problem in an asynchronous system where any number out of n processes can crash • K-Set Agreement: While consensus requires all processors to decide on the same value, k-set agreement allows the processes to decided on at most k different values • 0 < k < n : k = 1 is consensus, k = n is trivial Wait-free k-set agreement is impossible

8. More generally, if t can crash • t=1, k=1 : consensus impossibility [FLP] Fischer, Lynch, Paterson, 1985 • Dijkstra Award 2001 k-set agreement is possible if t < k But not if t >= k

9. So we have a t-solvable problem that is not t+1-solvable • Soma Chaudhuri introduced set agreement in PODC 1990 motivated by this challenge • It was only known FLP, Fischer, Lynch, Paterson: consensus is possible iff t < 1 • Soma described an algorithm and tried to generalize FLP’s bivalency argument for t • Working wait-free (t=n-1) is easier than t resilient k-set agreement is possible if t < k But not if t >= k

10. Why is this so important?

11. Why is the wait-free set agreement impossibility so important? • First step was FLP: consensus is impossible if t ≥ 1 • Then characterization for t = 1 • [BMZ’90] O. Biran, S. Moran, S. Zaks 1990, and • [MW’87] Moran, Y. Wolfstahl • Deciding if a problem is 1-solvable is NP-hard • Biran, Moran, Zaks 1990 • And other related papers for t=1 It lead to a characterization of the problems that are wait-free solvable

12. Important also because It opened the way to characterizations of the problems that are solvable in other models Many papers in this direction: • t - resilient • More powerful shared memory objects such as test&set • Compositions of objects to wait-free implement others • Unbounded number of processes • Synchronous and partially synchronous systems • Failure detectors • Conditions that restrict the inputs of a problem

13. And New Relations Between Models In any distributed computing model: • Topological properties determine problem solvability • And time complexity of the solutions • As a function of failure model and asynchrony assumptions • This has lead to new proofs with the same structure for both synchronous and asynchronous problems, and a more uniform theoretical foundation to the field • Consensus FLP impossibility vs. t+1 synchronous lower bound Essential link between: distributed computing and topology

14. To Understand the Topology Link • Let’s start by looking at a k-set algorithm • For t < k • In a shared memory system • Assuming snapshot operations are available (snapshots can be wait-free implemented in read/write memory)

15. Algorithm for k-Set agreement if t < k In a snapshot shared-memory system: • Each process writes its input to shared memory • Takes snapshots until it gets a viewvector with at least n-t inputs • Decides on the smallest input in its view Correctness: • They see views with ≤ t empty entries • Views are ordered by containment • There are at most t+1 different views => they solve k = t+1 -set agreement

16. The Views Obtained by the Processes • Each view is an input vector with at most t empty entries: • (1,2,3) a process saw that Pi wrote value i • In each execution each process has its view • P1 saw (0,1,2) • P2 saw (0,1,-) • Some processes may not distinguish between two executions

17. Some views after 1 round, starting with the same input vector, say (1,2,3): Views are Put TogetherThe case of 3 Processes,t =2 Each execution is represented by a triangle: simplex The corners of a simplex are labeled with the views of each of the 3 processes in the execution The set of all the executions is the union of all simplexes: protocol complex

18. Generating the ISE Protocol Complex (1) Immediate Snapshot Executions: a snapshot goes immediately after a write Both [BG] and [SZ] used ISE p1 Views P1: (1,-,-) P2: (1,2,-) P3: (1,2,3) Exec P1: wr P2: wr P3: wr p2 p3

19. Generating the ISE Protocol Complex (2) ISE: a snapshot goes immediately after a write Each vertex represents the local state of one process, 1 round: Views P1: (1,2,-) P2: (1,2,-) P3: (1,2,3) Exec P1: wr P2: wr P3: wr p2 p3 p1

20. Generating the ISE Protocol Complex (3) ISE: a snapshot goes immediately after a write Each vertex represents the local state of one process, 1 round: Exec P1: wr P2: wr P3: wr Views P1: (1,2,-) P2: (-,2,-) P3: (1,2,3) p3 p1 p2

21. Generating the ISE Protocol Complex (4) ISE: a snapshot goes immediately after a write Each vertex represents the local state of one process, 1 round: Views P1: (1,2,3) P2: (1,-,-) P3: (1,2,3) Exec P1: wr P2: wr P3: wr p3 p1 p2

22. Generating the ISE Protocol Complex (5) ISE: a snapshot goes immediately after a write Each vertex represents the local state of one process, 1 round: Views P1: (1,2,3) P2: (1,2,3) P3: (1,2,3) Exec P1: wr P2: wr P3 wr p3 p2 p1

23. The Decision is a function only of the process’ view P1 can decide only on the input from P2 or itself P2 can decide on its own input only Exec P1: wr P2: wr P3: wr Views P1: (1,2,-) P2: (-,2,-) P3: (1,2,3) p3 p1 p2

24. Decisions induce Sperner’s coloring on the vertices • In corners: Pi can decide only on its own input • In Pi-Pj boundary: P can decide only on Pi or Pj inputs p1 Exec P1: wr P2: wr P3: wr p3 p1 p3 p2

25. p3 p1 p3 p2 An input vector with 3 different inputs • P1 starts with • P2 starts with • P2 starts with p1 Exec P1: wr P2: wr P3: wr

26. Sperner’s coloring on the boundary p1 p1 p3 p2

27. Sperner’s Coloring in the inside arbitrary p1 p1 p3 p2

28. Sperner’s Lemma implies • At least one triangle has all 3 colors. • At least one execution has 3 different values decided • 2-set agreement, t=2, impossible in 1 round p1 p1 p3 p2

29. But 2-set agreement, t=1is possible(t<k) • Views with 2 empty places are removed => • The corners are removed p1 p3 p2

30. How to prove that k-set agreement, t ≥ k, is impossible in any number of rounds?let’s see for wait-free…

31. Sperner’s lemma holds for any subdivided simplex • Any subdivided simplex with a Sperner’s Coloring • Has a simplex with all colors

32. Wait-free views always induce a subdivision Main result of BG, HS, SZ : • More rounds create finer subdivision • One more round creates one more level of smaller triangles inside each triangle • Topological invariant: “wait-free is like a solid sphere” • No holes (of any dimension) • Each paper used different techniques to prove it, and new techniques have been proposed since then that are easier to apply to other models

33. Topological invariance induces the set agreement impossibility • Any wait-free protocol induces a subdivision (as below) • Decisions on an input vector with 3 values define a Sperner’s coloring • Sperner’s lemma implies • Set agreement is impossible for any number of rounds p1 p3 p2

34. A Sperner’s Lemma Proof (there are many) • The coloring says how to map a solid triangle into another triangle, sending boundary to boundary • Impossible to map it into a hollow triangle, no matter how much it is stretched (subdivided) or bent

35. 1-dimensional Sperner’s lemma • A connected complex cannot be mapped to a disconnected complex • => consensus is impossible with t > 0 p1 p2

36. Sperner’s lemma fundamental role • We saw Sperner’s lemma => set agreement unsolvable • The opposite is also true ! • (using approximate agreement protocol) • Equivalent to Brouwer’s Fixed Point Theorem • Shake a glass of water, one point remains fixed • One of the most used theorems of mathematics • Used for all of the distributed computing problems, except for symmetric version of renaming

37. The same framework is used for any decision problem

38. p3 The picture can be generalized from one input vector ( ) to another along the boundary • Change the input of p3 from to • Along the boundary p1 and p2: • do not know p3’s input and then • cannot distinguish from p1 p2 p1 p3 p2

39. Initial states for consensus • Processes: blue, red, orange. • Independently assign 0 or 1 • Isomorphic to 2-sphere • This is the input complex 0 0 1 0 1

40. States after 1 round, starting in the initial states for consensus • Running a wait-free protocol creates a subdivision of each input simplex • Topology of the input complex is preserved 0 0 1 0 1

41. What about more powerful models? Synchronous systems, asynchronous with more powerful primitives • More problems are solvable because holes are introduced into the subdivision Let’s see a 1-resilient asynchronous model…

42. States after 1 round (input 2 not shown) • Running a 1-resilient protocol creates holes • Topology of the input complex is not exactly preserved • 2-set agreement is possible 0 0 1 0 1

43. 2-set agreement is possible because now there is a map from the protocol complex into the hollow simplex 0 0 0 1 0 1 2 1

44. Synchronous Model • In t-resilient computation, t >1 there are holes, but do not change their type with the number of runs • In synchronous computation yes…

45. Synchronous protocol complex evolution Connected but not 1-connected zero one Disconnected two

46. Summarizing the importance of the papers

47. The Topology Link • Any algorithm in any model approx. preserves the • topology of the inputs to a problem • To solve a problem we need to create “holes” in the topology (to be able to map inputs to outputs) • Stronger models create more “holes” than weaker models; wait-free does not create any holes • Why a problem is solvable after more rounds? • Finer subdivisions of the inputs are produced, and • in some models also holes

48. Problem solvability is undecidable • For a distributed computing model, is there an algorithm solving a given problem? • No: wait-free and in other models [KG,HR] (yes in an asynchronous system if t=1, Moran et al) By reduction to a classic topology problem, equivalent to a classic algebra problem: Can a given loop be contracted in a complex?

49. Contractibility is undecidable contractible not contractible contractible

50. What does it mean? The Turing theory of computation has been extraordinary successful in providing the foundations for theoretical computer science Lenore Blum • The previous fundamental limitation is about distribution of resources, and due to uncertainty from delays and failures • NOT from the limitations of a Turing Machine