1. © Sergio Rajsbaum; DISC/GETCO 2004 Introduction to the Gödel Prize Session Sergio Rajsbaum Math Institute UNAM, Mexico

2. © Sergio Rajsbaum; DISC/GETCO 2004 About this Talk Aim: give an idea of what are the contributions of the awarded papers, their importance and context Informal and some cheating There are many subsequent papers motivated by the awarded papers, I discuss only some of them, and omit most references Sorry to authors I don’t mention explicitly Eric Goubault keeps web pages on the area –See GETCO’04 web page

3. © Sergio Rajsbaum; DISC/GETCO 2004 Authors that have worked in the area (not counting GETCO concurrency approach) Hagit Attiya Zvi Avidor Elizabeth Borowsky Soma Chaudhuri Eli Gafni Rachid Guerraoui John Havlicek Maurice Herlihy Gunnar Hoest Elias Koutsoupias Peter Kouznetsov Nancy Lynch Shlomo Moran Lucia Penso Bastian Pochon Nir Shavit Michael Saks Mark Tuttle Fotios Zaharoglou

4. © Sergio Rajsbaum; DISC/GETCO 2004 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

5. © Sergio Rajsbaum; DISC/GETCO 2004 2004 Gödel Prize Maurice Herlihy, Nir Shavit JACM 1999 Mike Saks, Fotios Zaharoglou SICOMP 2000 [HS] [SZ]

6. © Sergio Rajsbaum; DISC/GETCO 2004 2004 Gödel Prize And a third one with the same result, but not published in a journal: Liz Borowsky, Eli Gafni [BG] Both conference versions in STOC 1993

7. © Sergio Rajsbaum; DISC/GETCO 2004 The importance of the papers in a nutshell Lamport’s “Time, Clocks,…” paper is perhaps the first and most fundamental in distributed computing –1 st 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

8. © Sergio Rajsbaum; DISC/GETCO 2004 The Results

9. © Sergio Rajsbaum; DISC/GETCO 2004 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

10. © Sergio Rajsbaum; DISC/GETCO 2004 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

11. © Sergio Rajsbaum; DISC/GETCO 2004 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

12. © Sergio Rajsbaum; DISC/GETCO 2004 Why is this so important?

13. © Sergio Rajsbaum; DISC/GETCO 2004 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

14. © Sergio Rajsbaum; DISC/GETCO 2004 Important also because 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 It opened the way to characterizations of the problems that are solvable in other models

15. © Sergio Rajsbaum; DISC/GETCO 2004 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

16. © Sergio Rajsbaum; DISC/GETCO 2004 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)

17. © Sergio Rajsbaum; DISC/GETCO 2004 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 view vector 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

18. © Sergio Rajsbaum; DISC/GETCO 2004 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

19. © Sergio Rajsbaum; DISC/GETCO 2004 Views are Put Together The 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 Some views after 1 round, starting with the same input vector, say (1,2,3):

20. © Sergio Rajsbaum; DISC/GETCO 2004 Generating the ISE Protocol Complex (1) Immediate Snapshot Executions: a snapshot goes immediately after a write Both [BG] and [SZ] used ISE Exec P1: wr P2: wr P3: wr p1 p2 p3 Views P1: (1,-,-) P2: (1,2,-) P3: (1,2,3)

21. © Sergio Rajsbaum; DISC/GETCO 2004 Generating the ISE Protocol Complex (2) Exec P1: wr P2: wr P3: wr p1 p2 p3 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)

22. © Sergio Rajsbaum; DISC/GETCO 2004 Generating the ISE Protocol Complex (3) Each vertex represents the local state of one process, 1 round: Exec P1: wr P2: wr P3: wr p1 p2 p3 ISE: a snapshot goes immediately after a write Views P1: (1,2,-) P2: (-,2,-) P3: (1,2,3)

23. © Sergio Rajsbaum; DISC/GETCO 2004 Generating the ISE Protocol Complex (4) Each vertex represents the local state of one process, 1 round: Exec P1: wr P2: wr P3: wr p1 p2 p3 ISE: a snapshot goes immediately after a write Views P1: (1,2,3) P2: (1,-,-) P3: (1,2,3)

24. © Sergio Rajsbaum; DISC/GETCO 2004 Generating the ISE Protocol Complex (5) Each vertex represents the local state of one process, 1 round: Exec P1: wr P2: wr P3 wr p1 p2 p3 ISE: a snapshot goes immediately after a write Views P1: (1,2,3) P2: (1,2,3) P3: (1,2,3)

25. © Sergio Rajsbaum; DISC/GETCO 2004 The Decision is a function only of the process’ view Exec P1: wr P2: wr P3: wr p1 p2 p3 P1 can decide only on the input from P2 or itself P2 can decide on its own input only Views P1: (1,2,-) P2: (-,2,-) P3: (1,2,3)

26. © Sergio Rajsbaum; DISC/GETCO 2004 Decisions induce Sperner’s coloring on the vertices Exec P1: wr P2: wr P3: wr p1 p2 p3 In corners: Pi can decide only on its own input In Pi-Pj boundary: P can decide only on Pi or Pj inputs p1 p3

27. © Sergio Rajsbaum; DISC/GETCO 2004 An input vector with 3 different inputs Exec P1: wr P2: wr P3: wr P1 starts with P2 starts with p1 p2 p3

28. © Sergio Rajsbaum; DISC/GETCO 2004 Sperner’s coloring on the boundary p1 p2 p1 p3

29. © Sergio Rajsbaum; DISC/GETCO 2004 Sperner’s Coloring in the inside arbitrary p1 p2 p1 p3

30. © Sergio Rajsbaum; DISC/GETCO 2004 Sperner’s Lemma implies p1 p2 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 p3

31. © Sergio Rajsbaum; DISC/GETCO 2004 But 2-set agreement, t=1 is possible (t<k) Views with 2 empty places are removed => The corners are removed p2 p3 p1

32. © Sergio Rajsbaum; DISC/GETCO 2004 How to prove that k-set agreement, t ≥ k, is impossible in any number of rounds? let’s see for wait-free…

33. © Sergio Rajsbaum; DISC/GETCO 2004 Sperner’s lemma holds for any subdivided simplex Any subdivided simplex with a Sperner’s Coloring  Has a simplex with all colors

34. © Sergio Rajsbaum; DISC/GETCO 2004 Wait-free views always induce a subdivision 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 Main result of BG, HS, SZ :

35. © Sergio Rajsbaum; DISC/GETCO 2004 Topological invariance induces the set agreement impossibility p2 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

36. © Sergio Rajsbaum; DISC/GETCO 2004 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

37. © Sergio Rajsbaum; DISC/GETCO 2004 1-dimensional Sperner’s lemma A connected complex cannot be mapped to a disconnected complex => consensus is impossible with t > 0 p2 p1

38. © Sergio Rajsbaum; DISC/GETCO 2004 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

39. © Sergio Rajsbaum; DISC/GETCO 2004 The same framework is used for any decision problem

40. © Sergio Rajsbaum; DISC/GETCO 2004 The picture can be generalized from one input vector ( ) to another along the boundary p2 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 p3 p2 p1 p3

41. © Sergio Rajsbaum; DISC/GETCO 2004 Initial states for consensus 0 Processes: blue, red, orange. Independently assign 0 or 1 Isomorphic to 2-sphere This is the input complex 0 0 1 1

42. © Sergio Rajsbaum; DISC/GETCO 2004 States after 1 round, starting in the initial states for consensus 0 Running a wait-free protocol creates a subdivision of each input simplex Topology of the input complex is preserved 0 0 1 1

43. © Sergio Rajsbaum; DISC/GETCO 2004 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…

44. © Sergio Rajsbaum; DISC/GETCO 2004 States after 1 round (input 2 not shown) 0 Running a 1-resilient protocol creates holes Topology of the input complex is not exactly preserved  2-set agreement is possible 0 0 1 1

45. © Sergio Rajsbaum; DISC/GETCO 2004 2-set agreement is possible because now there is a map from the protocol complex into the hollow simplex 0 0 0 1 1 0 12

46. © Sergio Rajsbaum; DISC/GETCO 2004 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…

47. © Sergio Rajsbaum; DISC/GETCO 2004 Single Input: Round One 0 00 0 00 0 00 00 00 0 0 0 0 0 0 0 0 no one fails orange fails red fails blue fails

48. © Sergio Rajsbaum; DISC/GETCO 2004 Single Input: Round One 0 00 0 00 0 00 00 00 0 0 0 0 0 0 0 0 red sends to blue But not to orange blue fails

49. © Sergio Rajsbaum; DISC/GETCO 2004 Single Input: Round One 0 00 0 00 0 00 00 00 0 0 0 0 0 0 0 0 red sends to no one blue fails

50. © Sergio Rajsbaum; DISC/GETCO 2004 Single Input: Round One 0 00 0 00 0 00 00 00 0 0 0 0 0 0 0 0 So if the input of red changes no one notices blue fails

51. © Sergio Rajsbaum; DISC/GETCO 2004 Protocol complex: round one of all executions on all inputs

52. © Sergio Rajsbaum; DISC/GETCO 2004 Protocol complex: round two of all executions on all inputs

53. © Sergio Rajsbaum; DISC/GETCO 2004 Synchronous protocol complex evolution zero two one Connected but not 1-connected Disconnected

54. © Sergio Rajsbaum; DISC/GETCO 2004 Summarizing the importance of the papers

55. © Sergio Rajsbaum; DISC/GETCO 2004 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? 1.Finer subdivisions of the inputs are produced, and 2.in some models also holes

56. © Sergio Rajsbaum; DISC/GETCO 2004 Problem solvability is undecidable By reduction to a classic topology problem, equivalent to a classic algebra problem: Can a given loop be contracted in a complex? 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)

57. © Sergio Rajsbaum; DISC/GETCO 2004 Contractibility is undecidable not contractible contractible

58. © Sergio Rajsbaum; DISC/GETCO 2004 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

59. © Sergio Rajsbaum; DISC/GETCO 2004 And it comes from two “axioms” Next-states have some degree of connectivity Degree of connectivity of neighbors is somewhat preserved A state A neighbor

60. © Sergio Rajsbaum; DISC/GETCO 2004 And it comes from two “axioms” Next-states have some degree of connectivity Degree of connectivity of neighbors is somewhat preserved Less connected neighbors

61. © Sergio Rajsbaum; DISC/GETCO 2004 Conclusions The 2004 Gödel Award papers have been greatly influential, motivating a lot of subsequent work, as well as changing the way we understand distributed computing There are many open problems about: –Proving topological properties of specific models –Establishing consequences of these –E.g. Byzantine failures, randomized, self-stabilization, network topology

62. © Sergio Rajsbaum; DISC/GETCO 2004 We have seen a “cut” perspective of the computation Considering how each execution is deformed into another, we get an orthogonal topology theory Introduced by Eric Goubault in ~93, with follow up by CONCUR community Considered the states at the end of a run

63. © Sergio Rajsbaum; DISC/GETCO 2004 Congratulations to the authors of the three papers !