Fouttolerantie in Gedistribueerde Algoritmen

Transcriptie

1 Collegedictaat Fouttolerantie in Gedistribueerde Algoritmen Gerard Tel 12 Vakgroep Informatica, Rijksuniversiteit Utrecht Postbus , 3508 TB Utrecht Zomer The work of the author was partially supported by the ESPRIT II Basic Research Actions Program of the EC under contract no (project ALCOM). 2 Met dank aan Petra van Haaften voor haar correctiewerk.

2 2

3 Inhoudsopgave 1 Fouttolerantie Robuuste Algoritmen Foutmodellen Beslisproblemen Resultaten Stabiliserende Algoritmen Beslisproblemen Het Model De stelling van Fischer, Lynch en Paterson Loze processen Algemenere Beslisproblemen Gerandomiseerde Consensus Een Stop Robuust Protocol Een Byzantijn Robuust Protocol Byzantijnse Broadcast Naamgeving en Electie Naamgeving Ondergrenzen Een Algemeen Algoritme voor Naamgeving Algoritme voor Uniciteit Algoritme voor Ordening Electie Eerste Observaties Het Algoritme van Masuzawa et al Electie van Meerdere Leiders Synchrone Beslisprotocollen Een Broadcast Protocol Een Bovengrens op t Het Gebruik van Authenticatie Andere Beslisproblemen i

4 ii INHOUDSOPGAVE 6 Kloksynchronisatie Begrippen en Notaties Het Lezen van een Niet locale Klok Een Deterministisch Protocol Een Probabilistisch Protocol Een Gedistribueerd Algoritme Inexact Agreement Gebruik voor Kloksynchronisatie Interne en Externe Synchronisatie Andere Algoritmen De Implementatie van Ronden Stabilisatie Inleiding Systemen en Berekeningen Specificaties Eerste Resultaten Uitsluiting: Niet Uniforme Oplossingen Een Gerichte Oplossing Een Compacte Oplossing Uitsluiting: Een Uniforme Oplossing Stabiliserende Netwerk Algoritmen Het Alternating Bit Protocol Probleemstelling en Specificatie Het Protocol Attractoren en Pseudo Attractoren Bewijs van Pseudo Stabilisatie Een Routerings Algoritme Probleemstelling en Specificatie Het Algoritme Bewijs van Stabilisatie Variaties op het Algoritme

5 Hoofdstuk 1 Fouttolerantie In dit dictaat beschouwen we algoritmen voor gedistribueerd functioneel gedrag van processen, waarbij met name wordt gekeken naar de vraag, welk functioneel gedrag nog te bereiken is indien één of meer processen in het systeem gebrekig kunnen zijn. Voor een algemene inleiding in gedistribueerde algoritmen, zie [Tel00]. Er zijn verschillende motieven om de complicaties, ontstaan door de mogelijkheid van gebrekige processen, te onderzoeken in een gedistribueerde omgeving. In veel gedistribueerde systemen kan de mogelijkheid van het optreden van een storing tijdens de executie van een algoritme niet worden uitgesloten. Computers in een computernetwerk kunnen down gaan, en (met name lange afstands ) verbindingen kunnen een bericht niet of verkeerd doorgeven. Zelfs als de componenten van een systeem elk zeer betrouwbaar zijn, kan de kans op het optreden van een storing toch willekeurig groot worden indien het systeem zeer veel componenten bevat. Anders dan bij een systeem bestaande uit één proces (of processor) zijn er in een gedistribueerd systeem nog correct werkend componenten over na een storing in één process. In het geval van één proces betekent verlies van dit proces (of deze processor) dus het verlies van het gehele systeem, in een gedistribueerde omgeving slechts het verlies van een gedeelte van het systeem. Het valt dus te onderzoeken in hoeverre de resterende processen (of processoren) in het systeem de functie van de verloren processen kunnen opvangen en hun fouten corrigeren. Reeds in een vroeg stadium van de ontwikkeling van computers die extreem betrouwbaar moeten zijn heeft men daarom computers gerepliceerd. Het computersysteem van de Space Shuttle bestaat bijvoorbeeld uit vier identieke computers, die alle exact dezelfde berekening uitvoeren. In geval van een storing in één van deze computers wordt de besturing overgenomen door de andere computers [SG84]. Hoewel replicatie een voor de hand liggende oplossing lijkt om de betrouwbaarheid te vergroten, is het ontwerp van algoritmen om een cluster van (mogelijkerwijs gebrekige) computers te laten samenwerken verre van eenvoudig. Dit wordt geïllustreerd door het uitstel van de eerste lancering van de Shuttle (van 8 naar 10 april 1981), dat te wijten was aan een fout in de software die juist deze taak vervulde. De bescherming tegen storingen zal vanuit twee invalshoeken worden bestudeerd. Eerst zullen zogenaamde robuuste algoritmen worden besproken, later zogenaamde zelf stabiliserende algoritmen. Als korte inleiding op de volgende hoofdstukken wordt hier in het kort iets over beide typen algoritmen gezegd. 1

6 2 HOOFDSTUK 1. FOUTTOLERANTIE 1.1 Robuuste Algoritmen In robuuste algoritmen wordt elke stap van het algoritme met voldoende zorg omkleed om te garanderen, dat elk correct proces steeds slechts correcte stappen zet en met correcte informatie werkt. Om dit te bereiken worden strategieën gebruikt als het stemmen over informatie, waarbij informatie pas door een proces wordt geaccepteerd wanneer voldoende processen verklaren met dezelfde informatie te werken Foutmodellen Voor de precieze uitwerking van de algoritmen is het van groot belang, te weten op welke manieren een storing zich kan openbaren. De volgende foutmodellen worden in de literatuur onderscheiden. Loze processen: Een proces is Loos wanneer dit proces in het geheel niet actief wordt. Het proces voert dus geen enkele instructie van zijn algoritme uit. Stop of Crash: Een proces stopt wanneer het tot een zeker moment handelt volgens het algoritme, en daarna in het geheel niets meer doet. Omissie: Een Omissie in een proces is het overslaan van een bepaalde actie (meestal het verzenden van een bericht), waarna de uitvoering van het algoritme wordt hervat na de overgeslagen stap. Byzantijns: Een proces is Byzantijns wanneer het acties doet (in het bijzonder, berichten verstuurt) die niet in het algoritme zijn voorgeschreven, of acties niet doet die wel zijn voorgeschreven. Een loos proces is een speciaal geval van een stoppend proces, want een loos proces kan worden gezien als een proces dat stopt voor uitvoering van de eerste instructie. Een stoppend proces kan gezien worden als een speciaal geval van een omissie storing, namelijk, de omissie van alle acties vanaf een bepaald moment. Een omissie is een speciaal geval van Byzantijns gedrag. Hierdoor zijn stoppende processen moeilijker te tolereren dan loze processen, omissies moeilijker dan stoppende processen, en Byzantijnse processen moeilijker dan omissies. Verder worden (tenzij anders vermeld) in de hoofdstukken over robuuste algoritmen de volgende aannamen gemaakt. Alleen processen zijn gebrekig, de kanalen zijn betrouwbaar. (Een gebrekig kanaal kan worden gemodelleerd door een storing in één der aanliggende processen.) Als een correct proces een bericht verstuurt aan een correct proces, wordt dit bericht ongewijzigd en binnen eindige tijd ontvangen Beslisproblemen De eerste problemen die bekeken worden lijken zeer eenvoudig, en zouden in een foutvrije omgeving met een zeer eenvoudig algoritme op te lossen zijn. De processen moeten allemaal eenmaal een waarde naar hun output schrijven. Deze problemen zullen we aanduiden als beslisproblemen omdat elk proces een beslissing moet nemen over de waarde die het naar de output schrijft. De beslissing van een proces is niet herroepbaar. In de diverse beslisproblemen die in de volgende hoofdstukken besproken worden zullen steeds nadere eisen aan de waarde van de output van de processen worden gesteld. Hierbij is

7 1.1. ROBUUSTE ALGORITMEN 3 het van belang op te merken, dat er alleen eisen worden opgelegd aan de output van correcte processen. Een specificatie waarin een zekere beslissing wordt geëist in een gebrekig proces kan nooit worden geïmplementeerd, omdat een gebrekig proces altijd kan falen voor het een beslissing genomen heeft. De eisen die aan de output worden gesteld zijn steeds van drie typen, namelijk voortgangs, consistentie, en niet trivialiteits eisen. Een voortgangs eis vereist dat alle correcte processen een beslissing zullen nemen. Een dergelijke conditie sluit natuurlijk oplossingen uit, waarin een proces wacht op ontvangst van informatie van (bijna) alle andere processen; immers, het proces kan oneindig lang blijven wachten als een gebrekig proces geen informatie opstuurt. Er wordt onderscheid gemaakt tussen deterministische en probabilistische algoritmen (als in [Tel00, Hfs. 9]). In een deterministisch algoritme wordt een beslissing genomen (in alle correcte processen) in elke berekening. In een probabilistisch algoritme wordt een beslissing genomen met een voldoend grote kans, meestal 1. Een consistentie eis legt een relatie tussen de outputwaarden van de verschillende processen. In het eenvoudigste geval wordt simpelweg gelijkheid vereist, dus dat alle correcte processen op dezelfde waarde beslissen. (Welke waarde dat precies is kan weer aan nadere condities gebonden zijn.) Wanneer gelijkheid wordt geëist spreken we van consensus. In meer ingewikkelde voorbeelden kan een klasse van outputvectoren worden gedefiniëerd (als in sectie 2.4). Men denke bijvoorbeeld aan het electieprobleem (zie hoofdstuk 4 of [Tel00, Hfs. 7]). In dit geval houdt de consistentie eis in dat er precies één proces de beslissing gekozen neemt, en alle andere processen de beslissing niet gekozen. Wanneer een algoritme voor een beslisprobleem wordt gegeven zullen de genoemde eisen in het algemeen voldoende zijn. In de gevallen waar we zullen bewijzen dat een probleem niet opgelost kan worden is een aanvullende eis van technische aard nodig. Wanneer slechts een voortgangs en een consistentie eis gelden, kan men een toegestane oplossing voorselecteren en een algoritme geven dat in elk proces deze oplossing naar de uitvoer schrijft. Een niet trivialiteits eis sluit deze algoritmen uit door te eisen dat (essentiëel) verschillende uitvoerwaarden voor moeten kunnen komen als resultaat van de uitvoer van het algoritme. Beslisproblemen zijn een abstractie van zeer veel voorkomende situaties in gedistribueerde systemen. Commit/Abort: In een gedistribueerde database moet een transactie worden doorgevoerd in alle sites, of in geen. Nadat een transactie bij alle sites bekend is gemaakt, bepaalt elke site of die transactie in die site uitgevoerd kan en mag worden. Vervolgens moeten alle sites dezelfde beslissing nemen, of de transactie wordt uitgevoerd (Commit) of niet (Abort), waarbij de beslissing voor een Commit alleen genomen mag worden als de transactie in alle sites doorgevoerd kan worden. Berekeningen: Wanneer meerdere processen dezelfde berekening uitvoeren (om de betrouwbaarheid van het systeem te vergroten), moeten al die processen over dezelfde gegevens voor de berekening beschikken. Daarom moeten de gegevens met een fouttolerant algoritme aan de processen worden bekend gemaakt. Electie: Elk proces moet beslissen of het leider is of niet. Er moet steeds precies één proces zijn dat zich tot leider uitroept. De niet trivialiteits eis houdt hier in dat er in principe verschillende processen tot leider gekozen kunnen worden. Wanneer processen

8 4 HOOFDSTUK 1. FOUTTOLERANTIE kunnen falen, volgt dit uit de consistentie eis, zelfs indien men niet eist dat alle processen hetzelfde locale algoritme uitvoeren Resultaten Beslisproblemen worden behandeld in de hoofdstukken 2 tot en met 6. Er wordt in deze hoofdstukken steeds aangenomen dat de topologie van het netwerk compleet is, dus dat elk proces rechtstreeks met elk ander proces kan communiceren. Het aantal processen wordt met N aangeduid, en (een bovengrens op) het aantal gebrekige processen met t. In hoofdstuk 2 worden deterministische, asynchrone algoritmen bekeken. De resultaten in dat hoofdstuk zijn meest van negatieve aard. Er wordt namelijk een resultaat van Michael Fischer, Nancy Lynch en Michael Paterson [FLP85] besproken, dat zegt dat in dit model geen algoritme voor consensus bestaat dat bestand is tegen stoppen van processen. Een aanvullend resultaat van Shlomo Moran en Yaron Wolfstahl [MW87] generaliseert de onmogelijkheid naar een bredere klasse van beslisproblemen. Een conclusie is, dat stoppende processen alleen getolereerd kunnen worden door probabilistische of synchrone algoritmen. In hoofdstuk 3 worden daarom probabilistische asynchrone algoritmen bekeken. Met probabilistische methoden is een consensus wel te bereiken, zoals blijkt uit de behandelde algoritmen van Gabriel Bracha en Samuel Toueg [BT85]. Er wordt in dit hoofdstuk ook een grens afgeleid op het aantal gebrekige processen dat kan worden getolereerd. Het blijkt dat t stoppende processen kunnen worden getolereerd dan en slechts dan als N > 2t, en dat t Byzantijnse processen kunnen worden getolereerd dan en slechts dan als N > 3t. Deze verhoudingen vindt men steeds terug in algoritmen of onmogelijkheidsbewijzen voor stoppende of Byzantijse processen. De negatieve resultaten uit hoofdstuk 2 kunnen de indruk geven dat er in het geheel geen (niet triviale) beslisproblemen zijn die met een asynchroon deterministisch algoritme kunnen worden opgelost. Deze indruk is echter niet juist, zoals blijkt in hoofdstuk 4, dat ingaat op twee problemen die kunnen worden opgelost met een asynchroon deterministisch algoritme. Het betreft hier het uitdelen van proces namen in een systeem met stoppende processen en electie in een systeem met loze processen. De behandelde algoritmen geven inzicht in de technieken die voor asynchrone deterministische robuuste algoritmen moeten worden aangewend. In hoofdstuk 5 wordt opnieuw het bereiken van consensus onder de loep genomen, en wel voor synchrone systemen. Er worden verschillende algoritmen behandeld voor het bereiken van consensus in dit model. In dit hoofdstuk blijkt dus dat, waar het fout tolerantie betreft, de mogelijkheden van synchrone systemen groter zijn dan van asynchrone systemen. Dit resultaat contrasteert met de resultaten die bekend zijn voor fout vrije systemen (zie bv. [Tel00, Hfs. 11]): fout vrije asynchrone systemen kunnen fout vrije synchrone systemen met een eenvoudig algoritme simuleren. Een consequentie van dit onderscheid is, dat het implementeren van synchroniteit in een gebrekige, volledig asynchrone omgeving niet mogelijk is. Hoofdstuk 6 behandelt de implementatie van synchroniteit, waarbij wordt aangenomen dat de processen beschikken over locale klokken en een bovengrens bekend is op de transmissietijd van een enkel bericht. Onder deze aannamen kunnen de locale klokken worden gesynchroniseerd, dat wil zeggen dat ze binnen bekende grenzen ongeveer dezelfde tijd aanwijzen. Het is dan mogelijk de executie van opeenvolgende ronden te sturen door van de locale klok gebruik te maken. De mogelijkheiden voor het bereiken van fout tolerantie door middel van gedistribueerde

9 1.2. STABILISERENDE ALGORITMEN 5 algoritmen zijn met deze hoofdstukken ongeveer in kaart gebracht. Er blijven echter nog vele onderwerpen over voor verdere studie, waarvan er hier een aantal volgen. 1. De complexiteit van fout tolerantie. Om de presentatie elementair te houden is steeds gekozen voor de behandeling van eenvoudige algoritmen voor een bepaald probleem. Vaak bestaan er alternatieven die het probleem oplossen met minder berichten of in minder tijd (ronden ingeval van synchrone algoritmen). 2. Precisering van de synchroniteits aannamen. Er worden in dit boek slechts twee extreme aannamen betreffende synchroniteit gemaakt, te weten volledig asynchrone executie en geïdealiseerde synchrone berekeningen die verlopen in ronden. Er zijn nog tussenliggende modellen denkbaar, bijvoorbeeld een model waar communicatie tussen twee processen instantaan is, of een zogenaamd Archimedisch model. Voor een analyse van de mogelijkheden van een brede klasse van synchroniteitsaannamen verwijzen wij naar de literatuur, bijvoorbeeld een artikel van Danny Dolev, Cynthia Dwork en Larry Stockmeyer [DDS87]. 3. Precisering van de klasse van oplosbare problemen. Er wordt in dit boek van sommige problemen bewezen dat ze oplosbaar zijn, van anderen dat ze niet oplosbaar zijn (door deterministische asynchrone algoritmen). Verschillende auteurs hebben exacte graaf theoretische karakteriseringen gegeven van de beslisproblemen die oplosbaar zijn in de aanwezigheid van bijvoorbeeld één stoppend proces. Wij verwijzen hiervoor naar een artikel van Ofer Biran, Shlomo Moran en Shmuel Zaks [BMZ90], waarin tevens wordt bewezen dat deze karakteriseringen NP moeilijk zijn. 4. Men kan problemen formuleren voor een omgeving waarin wordt gecommuniceerd door middel van gemeenschappelijke variabelen in plaats van berichten. Voor enkele resultaten op dit gebied verwijzen we naar een artikel van Gadi Taubenfeld en Shlomo Moran [TM89]. 1.2 Stabiliserende Algoritmen Een stabiliserend (ook wel zelf stabiliserend genaamd) algoritme is een algoritme dat, ongeacht in welke configuratie het algoritme wordt gestart of zich bevindt, na een aantal stappen een gewenste configuratie bereikt, waarna het zich verder volgens de specificaties gedraagt. Stabiliserende algoritmen bieden bescherming tegen tijdelijke storingen ( transient faults ). Zelfs wanneer na een reeks van storingen de configuratie van het systeem inconsistent is en welke de waarde van de variabelen ook is, het algoritme zal altijd na enige tijd de normale, gewenste functionaliteit vertonen. Een verder voordeel van stabiliserende algoritmen is dat men zich geen moeite hoeft te geven het algoritme op een speciale manier te initialiseren. Stabiliserende en pseudo stabiliserende algoritmen worden behandeld in hoofdstukken 7 en 8. Een algoritme is pseudo stabiliserend wanneer elke berekening van het algoritme een suffix heeft die volgens de specificaties is. In hoofdstuk 7 wordt het onderwerp ingeleid en worden enkele stabiliserende algoritmen behandeld voor wederzijdse uitsluiting in een ring van processen. Aangenomen wordt in dat hoofdstuk dat de processen communiceren door het lezen van elkaars toestand (dus met gemeenschappelijke variabelen). Er wordt onderscheid gemaakt tussen uniforme en niet uniforme oplossingen, waarbij een oplossing uniform is wanneer alle processen gelijk zijn. Er

10 6 HOOFDSTUK 1. FOUTTOLERANTIE wordt bewezen dat een uniforme oplossing alleen mogelijk is indien het aantal processen een priemgetal is, en er worden uniforme en niet uniforme oplossingen gegeven. In hoofdstuk 8 tenslotte komen enkele stabiliserende algoritmen ter sprake voor de implementatie van netwerkfuncties. Er wordt bewezen dat het alternating bit protocol pseudo stabiliseert naar zijn specificatie, en er wordt een stabiliserend algoritme voor de berekening van routeringstabellen behandeld.

11 Hoofdstuk 2 Beslisproblemen In dit hoofdstuk wordt een zeer sterk resultaat van Michael Fischer, Nancy Lynch en Michael Paterson [FLP85] bewezen, namelijk, dat er geen deterministisch consensusprotocol bestaat dat bestand is tegen een crash van één proces. De onmogelijkheid volgt al wanneer slechts terminatie, consistentie en niet trivialiteit worden geëist, en is dus onafhankelijk van verdere eisen die aan de uitvoer worden opgelegd. Dit onmogelijkheidsresultaat wordt bewezen voor protocollen die beslissen op een waarde in het domein {0, 1}, waarbij dezelfde beslissing wordt geëist in elk proces. Het wordt aan de lezer overgelaten, de resultaten te generaliseren naar willekeurige verzamelingen. Er wordt ook bewezen (zie sectie 2.3), dat consensus wel te bereiken is ingeval er slechts loze processen, en geen crashes kunnen zijn. Het resultaat wordt gegeneraliseerd naar beslisproblemen, waarbij de processen niet noodzakelijk op dezelfde waarde moeten beslissen, maar een ander verband tussen de beslissingen van de verschillende processen wordt geëist (zie sectie 2.4). 2.1 Het Model Een onmogelijkheidsbewijs voor een bepaald probleem vereist in het algemeen een zeer precieze omschrijving van het onderliggende berekeningsmodel. Een onmogelijkheidsresultaat is namelijk een uitspraak over alle algoritmen die voor het systeem mogelijk zijn, en de beschrijving (het model) moet dus precies genoeg zijn om de relevante eigenschappen van alle mogelijke algoritmen te beschrijven. Tevens moet het model algemeen genoeg zijn om op verschillende computersystemen van toepassing te zijn. Van het model wordt verwacht, dat het een klasse van verwante systemen beschrijft. Welke de essentiële eigenschappen van het model zijn zullen we in de volgende hoofdstukken zien. Tenslotte dient het model compact van beschrijving te zijn. Immers, alle relevante aspecten van het model zullen in de bewijsvoering naar voren komen. Samenvattend, dient het model precies en kort de relevante eigenschappen van een klasse van computersystemen te beschrijven. Het model ziet er als volgt uit. Een protocol bestaat uit N (N 2) processen, die elk (o.a.) een input register x p en een output register y p hebben. De waarde van x p is 0 of 1; de waarde van y p is 0, 1 of b en dit register mag slechts éénmaal geschreven worden. Dit gebeurt wanneer proces p beslist. Een configuratie van het protocol bestaat uit de locale toestand 7

12 8 HOOFDSTUK 2. BESLISPROBLEMEN van elk proces en de berichtverzameling van alle berichten die in die configuratie onderweg zijn. Voor elk bericht is er slechts één proces, dat dit bericht kan ontvangen. In een initiële configuratie zijn alle y p registers gelijk aan b, en er zijn geen berichten onderweg. Een initiële configuratie is volledig vastgelegd door de waarden van de x p registers (voor alle p). Een stap in de berekening wordt genomen door één proces en bestaat uit het al dan niet ontvangen van één bericht, een verandering van de toestand van het proces, en het verzenden van nul of meer berichten. De stap wordt genoteerd als e = (p, m), waar p het proces is dat de stap neemt, en m het bericht dat ontvangen wordt (m = als er geen bericht wordt ontvangen in de stap). Een protocol is deterministisch: de toestand van p na het uitvoeren van e en de verzonden berichten zijn volledig bepaald door de toestand van p voor e en het ontvangen bericht m (evt. ). De stap e = (p, m) is toepasbaar in configuratie C als m = of m is onderweg (naar p) in configuratie C. De configuratie die ontstaat na de toepassing van e wordt genoteerd als e(c) en wordt als volgt uit C gevonden: 1. Als m dan is m uit de berichtverzameling verdwenen. 2. De toestand van p is veranderd. 3. Er kunnen berichten toegevoegd zijn aan de berichtverzameling. Een reeks σ = (e 1, e 2,..., e k ) van stappen is toepasbaar in een configuratie C 0 als e 1 toepasbaar is in C 0, e 2 is toepasbaar in C 1 = e 1 (C 0 ), etc., en e k is toepasbaar in C k 1. Als σ toepasbaar is in C 0 is σ(c 0 ) = e k (e k 1 (..(e 1 (C 0 ))..)). Configuratie D is bereikbaar uit C als er een reeks σ is zodanig dat σ(c) = D. Een configuratie heet bereikbaar als hij bereikbaar is uit een initiële configuratie. Een belangrijke eigenschap van asynchrone gedistribueerde systemen is, dat stappen in verschillende processen in willekeurige volgorde kunnen worden uitgevoerd, en dat de uiteindelijke configuratie niet van de volgorde afhangt. Lemma 2.1 Laat de reeksen σ 1 en σ 2 van stappen toepasbaar zijn in configuratie C, waarbij er geen proces is dat zowel een stap doet in σ 1 als in σ 2. Dan is σ 2 toepasbaar in σ 1 (C), en σ 1 toepasbaar in σ 2 (C), en σ 2 (σ 1 (C)) = σ 1 (σ 2 (C)). Bewijs. Doe zelf. Om te modelleren dat een correct proces niet faalt, zullen we aannemen dat een correct proces in het protocol altijd oneindig veel stappen doet. Merk op, dat elk protocol zo te veranderen is dat deze aanname geldt, namelijk door elk proces na een eventuele beslissing in een oneindige loop van lege stappen te laten komen. Een proces dat stopt (crasht) doet slechts eindig veel stappen. Een run is een oneindige reeks stappen. Definitie 2.2 Een run is een 1 Stop run als tenminste N 1 processen oneindig veel stappen doen in die run en elk bericht dat door een correct proces is verstuurd ook wordt ontvangen. (Een proces is correct als het oneindig veel stappen doet.) Een protocol is een Deterministisch 1 Stop Robuust consensusprotocol als aan de volgende eisen is voldaan: 1. Terminatie: In elke 1 Stop run beslissen alle correcte processen.

13 2.2. DE STELLING VAN FISCHER, LYNCH EN PATERSON 9 2. Consistentie: In geen bereikbare configuratie zijn er processen p en q met y p = 0 en y q = Niet-trivialiteit: Voor v = 0 èn voor v = 1 is er een bereikbare configuratie waarin er een p is met y p = v. Een configuratie heet 0 beslist als er in deze configuratie een p is met y p = 0 en 1 beslist als er een p is met y p = 1. Uit de terminatie eis volgt, dat er vanuit elke bereikbare configuratie van een deterministisch 1 Stop robuust beslisprotocol een (0 of 1 ) besliste configuratie bereikbaar is. Een configuratie C heet 0 valent als alle besliste configuraties die uit C bereikbaar zijn 0 beslist zijn, en 1 valent als alle besliste configuraties die uit C bereikbaar zijn 1 beslist zijn. Een configuratie C heet bivalent als zowel 0 als 1 besliste configuraties uit C bereikbaar zijn. 2.2 De stelling van Fischer, Lynch en Paterson Stelling 2.3 Er bestaat geen deterministisch 1 Stop robuust consensusprotocol (voor asynchrone systemen). Om de stelling te bewijzen wordt aangenomen dat er zo n protocol, P, is. Er zal een tegenspraak worden afgeleid, namelijk, dat er een 1 Stop run is waarin niet wordt beslist. Om zo n run te vinden, moet het protocol worden gestart in een bivalente initiële configuratie. Lemma 2.4 Er is een bivalente initiële configuratie van P. Bewijs. (1) Daar P niet triviaal is, zijn er initiële configuraties D 0 en D 1 zodanig dat vanuit D 0 een 0 besliste configuratie, en vanuit D 1 een 1 besliste configuratie bereikbaar is. (2) Als D 0 = D 1, dan is deze configuratie een bivalente initiële configuratie. Laat verder D 0 D 1. (3) Er zijn initiële configuraties C 0 en C 1 zodanig dat vanuit C 0 een 0 besliste configuratie, en vanuit C 1 een 1 besliste configuratie bereikbaar is, en C 0 en C 1 verschillen slechts in de input van één proces. (4) Om dit te bewijzen, beschouw een serie initiële configuraties, beginnend met D 0, en eindigend met D 1. Elke volgende configuratie wordt verkregen door van een proces, waarvan de input ongelijk is aan de input die dat proces in D 1 heeft, de input te veranderen in de input van dat proces in D 1. Omdat er vanuit elke initiële configuratie een besliste configuratie bereikbaar is, vanuit D 0 een 0 besliste, en vanuit D 1 een 1 besliste, kunnen C 0 en C 1 als in (3) gekozen worden als twee opeenvolgende configuraties in deze serie. (5) Noem het proces waarin C 0 en C 1 verschillen p, en zij r een 1 Stop run vanuit configuratie C 0 waarin p geen enkele stap neemt, en B de besliste configuratie die in die run wordt bereikt. (6) Als B 1 beslist is, is C 0 bivalent. (7) Als B 0 beslist is, is C 1 bivalent. Omdat C 0 en C 1 slechts in p verschillen en p geen stap doet in r, is r ook toepasbaar in C 1 en leidt naar dezelfde besliste configuratie B. Vervolgens wordt bewezen, dat elke stap kan worden genomen zonder dat hierdoor een beslissing wordt geforceerd.

14 10 HOOFDSTUK 2. BESLISPROBLEMEN Lemma 2.5 Zij C een bivalente configuratie en e = (p, m) toepasbaar in C. Zij C de verzameling configuraties die uit C bereikbaar zijn zonder e toe te passen, en D de verzameling configuraties die verkregen worden door e toe te passen op een configuratie in C: Dan is er een bivalente configuratie in D. C = {σ(c) e komt niet voor in σ}, D = {e(e) E C en e is toepasbaar in E}. Bewijs. (1) Merk eerst op, dat e toepasbaar is in alle configuraties E in C, want als m = is e altijd toepasbaar, en als e blijft m in de berichtenverzameling zolang e niet is toegepast. (2) Er zijn configuraties G 0 en G 1 in C, zodanig dat vanuit e(g 0 ) een 0 besliste, en vanuit e(g 1 ) een 1 besliste configuratie bereikbaar is. (3) Om G 0 en G 1 te vinden, merk op dat C bivalent is, dus er zijn een 0 besliste configuratie B 0 en een 1 besliste configuratie B 1 bereikbaar uit C. Als B i C, kies G i = B i (want e(b i ) is nog steeds i beslist). Als B i C, kies voor G i de configuratie in de berekening die van C naar B i leidt, van waaruit e is toegepast. (4) Als G 0 = G 1, dan is e(g 0 ) een bivalente configuratie in D en zijn we klaar. Veronderstel G 0 G 1. Beschouw de opeenvolgende configuraties in berekeningen die van C naar G 0 en G 1 leiden, en noem twee van deze configuraties buren als de ene configuratie volgt op de andere. Omdat er vanuit e(g 0 ) een 0 besliste configuratie bereikbaar is en vanuit e(g 1 ) een 1 besliste, volgt dat er 1. onder de beschouwde configuraties een C is waarvoor e(c ) bivalent is; of 2. twee buren C 0 en C 1 zijn waarvoor e(c 0 ) 0 valent en e(c 1 ) 1 valent is. In het eerste geval is e(c ) een bivalente configuratie in D. (5) Voor het tweede geval zullen we een tegenspraak afleiden. Er geldt C 1 = e (C 0 ) of C 0 = e (C 1 ), voor een stap e = (p, m ). Veronderstel C 1 = e (C 0 ) (het andere geval gaat analoog). Laat D 0 = e(c 0 ) en D 1 = e(c 1 ). Daar e(e (C 0 )) = D 1 een 1 valente configuratie is, en e (e(c 0 )) = e (D 0 ) een 0 valente configuratie, geldt e(e (C 0 )) e (e(c 0 )). Met lemma 2.1 volgt nu dat p = p. (6) In configuratie C 0 is de beslissing over de uiteindelijke output geheel in handen van proces p, immers p kan het systeem naar de 0 valente configuratie D 0 of naar de 1 valente configuratie D 1 voeren. (7) Hieruit volgt dat er niet beslist kan worden als p in deze configuratie stopt. Zij namelijk σ een reeks van stappen, die toepasbaar is in C 0, en waarin p geen stap doet, en laat A = σ(c 0 ). Met hernieuwde toepassing van lemma 2.1 volgt dat e(a) = e(σ(c 0 )) = σ(e(c 0 )) = σ(d 0 ) is 0 valent, en e(e (A)) = e(e (σ(c 0 )) = σ(e(e (C 0 ))) = σ(d 1 ) is 1 valent, en dus is A bivalent. (8) Er is dus een 1 Stop run (namelijk elke run die het systeem in configuratie C 0 voert en daarna geen stap meer doet voor p) waarin niet wordt beslist. Dit is een tegenspraak met de terminatie eis. Bewijs. (Van stelling 2.3.) Zij P zo n protocol. Er kan een (1 Stop) run r worden geconstrueerd waarin geen proces ooit beslist. Zij A 0 een bivalente initiële configuratie van P (lemma 2.4). De run begint in deze configuratie en wordt telkens met een eindig stuk verlengd tot een volgende bivalente configuratie. In A i, kies voor p i één van de processen die het langst geen stap hebben uitgevoerd, en kies voor m i één van de berichten voor p i die al het langst

15 2.3. LOZE PROCESSEN 11 onderweg zijn ( als geen berichten naar p i onderweg zijn). Laat e i = (p i, m i ), en laat A i+1 een bivalente configuratie zijn waarin e i is toegepast (die bestaat volgens lemma 2.5). Verleng de run met de stappen die van A i naar A i+1 leiden. Deze constructie geeft een oneindige run, waarin alle processen correct zijn, en waarin nooit een besliste configuratie wordt bereikt. Dit is in tegenspraak met de terminatie eis. Conclusies uit deze stelling. Fischer, Lynch en Paterson hadden niet de bedoeling, aan te tonen dat er nooit beslissingen kunnen worden genomen in een gedistribueerd systeem. Er bestaan nl. wel gedistribueerde beslisprotocollen, maar die vereisen altijd dat extra aannamen over het systeem worden gemaakt. Het werk van Fischer, Lynch en Paterson toont aan, dat minstens één van deze aannamen ook werkelijk nodig is om het probleem op te lossen. Wijzigingen in het model die het probleem oplosbaar maken zijn bijvoorbeeld: 1. Een beperking van het gedrag dat mogelijk is voor defecte processen (zie sectie 2.3). 2. Het toestaan van randomisatie in de protocollen, en het tegelijkertijd verzwakken van de terminatie eis (zie hoofdstuk 3). 3. De aanname dat het systeem synchroon is (zie hoofdstuk 5). 2.3 Loze processen In deze sectie nemen we aan, dat een proces niet meer kan falen wanneer het eenmaal aan de berekening heeft deelgenomen. De enige manier waarop een proces kan falen is, door in het geheel niets te doen vanaf het begin van een executie. Een proces dat op deze manier faalt noemen we een loos proces. De correctheid van een consensusprotocol onder dit foutmodel wordt gedefinieerd in analogie met definitie 2.2: Definitie 2.6 Een run is een t Loze run als tenminste N t processen stappen doen in die run, elk proces dat een stap doet, oneindig veel stappen doet, en elk bericht dat is verstuurd ook wordt ontvangen. Een protocol is een Deterministisch t Loos Robuust consensusprotocol als aan de volgende eisen is voldaan: 1. Terminatie: In elke t Loze run is er een proces p dat y p op 0 of 1 zet. 2. Consistentie: In geen bereikbare configuratie zijn er processen p en q met y p = 0 en y q = Niet-trivialiteit: Voor v = 0 èn voor v = 1 is er een bereikbare configuratie waarin er een p is met y p = v. Stelling 2.7 Er bestaat een deterministisch t Loos robuust consensusprotocol voor elke t < N 2 (dat O(N 2 ) boodschappen gebruikt). Bewijs. Algoritme 2.1 op bladzijde 12 heeft de genoemde eigenschappen. Merk op, dat er meer dan N 2 correcte processen zijn als t < N 2. In fase 1 van het algoritme stuurt elk proces een bericht met zijn identiteit naar alle andere processen, en wacht tot het L = N 1 2 van deze berichten van andere processen

16 12 HOOFDSTUK 2. BESLISPROBLEMEN Fase 1: Proces p zendt p naar elk proces q p. Wacht tot L berichten p 1... p L zijn ontvangen (waar L = N 1 2 ). Zet P red p = {p 1,..., p L } Fase 2: Proces p zendt p, P red p, x p naar elk proces q p. Zet Anc p = P red p. Op ontvangst van q, P red, x : Sla bericht op. while er is een opgeslagen q, P red, x met q Anc p maar P red q Anc p do Anc p := Anc p P red. Ga door naar fase 3 zodra een q, P red, x is ontvangen van elke q Anc i. Fase 3: Proces p berekent een topkliek K in G + Beslis op grond van de inputs van processen in K. Algoritme 2.1: Deterministisch t Loos Robuust Beslisprotocol ontvangen heeft. Deze fase leidt niet tot deadlock, omdat er buiten elk correct proces nog minstens N t 1 L andere correcte processen zijn, zodat een correct proces voldoende berichten zal ontvangen om de fase af te sluiten. Fase 1 definieert op de processen een gerichte graaf, waarin er een kant (p, q) is als p door q werd ontvangen onder de eerste L berichten. (Berichten uit deze fase worden genegeerd door processen die al in een latere fase zijn.) In fase 2 berekent elk proces (een gedeelte van) de transitieve afsluiting G + van G. In de transitieve afsluiting G + is er een kant (q, r) als er in G een pad van q naar r is (evt. van lengte 0, dus q = r). In het door p berekende deel G + p is er een kant (q, r) als er een kant (q, r) en een kant (r, p) in G + zijn. Elk proces stuurt de verzameling van zijn inkomende kanten van G naar alle andere processen, en wacht tot het zo n bericht heeft ontvangen van al zijn voorouders in G. Hieruit berekent proces p G + p. Ook in fase 2 treedt geen deadlock op. Immers, p wacht slechts op de ontvangst van een bericht van q voor processen q Anc p, hetgeen impliceert dat er al een proces een bericht van q heeft ontvangen, en dus is q niet loos. In fase 3 doen de processen een lokale berekening die berust op een graaftheoretisch resultaat. Een topkliek in G + is een kliek zonder inkomende kanten, dat is, een verzameling K, zodanig dat: (1) voor elke p, q K zijn er kanten (p, q) en (q, p), (2) er zijn geen kanten (p, q) met p K en q K. Een niet triviale topkliek is een topkliek die uit minstens twee knopen bestaat. Claim 2.8 G + heeft één niet triviale topkliek K, die meer dan N 2 en is bevat in elke G + p (van een correct proces p). knopen heeft, Bewijs. Een loos proces is een geïsoleerde knoop van G en elk loos proces vormt een triviale topkliek in G +. Beschouw verder G + zonder de geïsoleerde knopen. De resterende graaf is weer een transitieve gerichte graaf en bevat dus minstens één topkliek. Daar een correct proces L inkomende kanten heeft in G, en dus > L inkomende kanten heeft in G +, bestaat zo n topkliek uit tenminste L + 1 > N 2

17 2.4. ALGEMENERE BESLISPROBLEMEN 13 knopen, en is dus niet triviaal. Omdat topklieken disjunct zijn, volgt nu dat er slechts één niet triviale topkliek K in G + is. Omdat elk correct proces p L inkomende kanten in G heeft, volgt dat p of één van zijn voorgangers in K zit, waaruit onmiddelijk volgt dat K in G + p zit. Alle processen berekenen in fase 3 een topkliek in G + p, en met claim 2.8 volgt dat zij alle dezelfde verzameling K berekenen. Zij kunnen nu beslissen op (bijvoorbeeld) de waarde die onder deze verzameling inputs de meerderheid heeft. Opgave 2.1 Bewijs dat er geen t Loos robuust consensusprotocol bestaat voor t N Algemenere Beslisproblemen Tot nu toe werd voor protocollen de consistentie eigenschap gehanteerd die vereist dat alle (correcte) processen op dezelfde waarde beslissen. Shlomo Moran en Yaron Wolfstahl [MW87] gaven een meer algemene definitie waarin het mogelijk is om in plaats van gelijkheid een zwakker functioneel verband tussen de uitvoerwaarden van verschillende processen te eisen. Door een reductie naar het consensusprobleem werd bewezen dat er geen deterministisch asynchroon 1 Stop robuust protocol bestaat voor vele van deze algemenere beslisproblemen. Zij X de verzameling mogelijke inputs voor een proces, en D de verzameling mogelijke outputs. Proces p heeft een input x p X en een output d p D, die weer slechts éénmaal geschreven mag worden. De input van alle processen samen is te schrijven als een vector in X N, en de output van alle (correcte) processen is te schrijven als een (partiële) vector in D N. Een taak is een afbeelding van de input naar een verzameling mogelijke outputs: T : X N P(D N ) De betekenis van deze functie is, dat als de input de vector x is, de output elke vector in T ( x) mag zijn. De verzameling D T is de verzameling van alle mogelijke outputs, dus het bereik van T. Voorbeeld 1, Consensus: De output is een vector met alle waarden gelijk, dus D Consensus = {(0, 0,.., 0), (1, 1,.., 1)}. Voorbeeld 2, Approximate Agreement: In het probleem van ɛ Approximate Agreement heeft elk proces een reëel getal als invoer en als uitvoer. De eisen op de uitvoer zijn (ɛ Agreement) dat de uitvoerwaarden van verschillende processen ten hoogste ɛ verschillen, en (Validiteit) dat alle outputwaarden tussen het minimum en het maximum van de invoerwaarden liggen. Omdat elk reëel getal invoer kan zijn, is hier D Approx = {(d 1,.., d N ) max(d i ) min(d i ) ɛ}.

18 14 HOOFDSTUK 2. BESLISPROBLEMEN Voorbeeld 3, Electie: In het Electie probleem moet er precies één proces in de toestand winnaar worden gebracht, en alle andere processen in de toestand verslagen. Wanneer winnaar met 1 wordt weergegeven en verslagen met 0, is de verzameling outputs gegeven door D Electie = {(1, 0,.., 0), (0, 1,.., 0),..., (0, 0,.., 1)}. Er zal bewezen worden dat er geen 1 Stop robuust electie algoritme bestaat; in hoofdstuk 4 zal worden bewezen, dat het Electie probleem wèl oplosbaar is in het model van loze processen. Voorbeeld 4, Opspannende boom: Om gedistribueerd een opspannende boom te berekenen, bepaalt elk proces een deelverzameling van {1,.., N}, waarvan de elementen zijn buren in de boom zijn. Hier is dus D = P({1,.., N}), en D OpBoom = {(d 1,..d N ) p d q q d p de d i definieren een boom}. Voorbeeld 5, Ranking: De invoer van elk proces is een natuurlijk getal. De uitvoer van een proces is de index van zijn invoer in een mogelijke sortering van alle inputs, dat wil zeggen, d p {1,.., N}, d p d q (voor p q), en d p < d q x p x q. Er geldt D Ranking = {π π is een permutatie van {1,.., N}}. Er zal worden bewezen dat er geen 1 Stop robuust ranking algoritme bestaat; in hoofdstuk 4 zal worden bewezen, dat het wel mogelijk is, de outputs in een groter bereik te kiezen met behoud van ordening. De beslisgraaf van T is de graaf G T = (V, E) waarin V = D T, en E = {( d 1, d 2 ) d 1 en d 2 verschillen slechts in één component}. Taak T heet samenhangend als G T een samenhangende graaf is, en onsamenhangend als G T onsamenhangend is. De correctheidseisen die voor een beslisprotocol moeten gelden werden door Moran en Wolfstahl nog verzwakt: slechts wanneer alle processen correct zijn, moet de outputvector in D T zitten. Wel wordt geëist, dat alle correcte processen een beslissing nemen, ook als er een crash is. (Een 0 Stop run is een run waarin alle processen oneindig veel stappen nemen.) Definitie 2.9 Een protocol is een deterministisch 1 Stop robuust T algoritme als aan de volgende eisen is voldaan: 1. Terminatie: In elke 1 Stop run beslist elk correct proces op een waarde in D. 2. Consistentie: In elke 0 Stop run geldt voor de vector d van outputs d T ( x). 3. Niet trivialiteit: Voor elke d D T is er een bereikbare configuratie met output d. Stelling 2.10 Er is geen deterministisch 1 Stop robuust T algoritme voor een onsamenhangende taak T.

19 2.4. ALGEMENERE BESLISPROBLEMEN 15 Bewijs. Een dergelijk protocol P is uit te breiden tot een beslisprotocol P waarin alle processen op dezelfde waarde beslissen, hetgeen volgens stelling 2.3 onmogelijk is. Neem in het bewijs aan, dat G T uit twee samenhangscomponenten 0 en 1 bestaat. De uitbreiding naar meerdere samenhangscomponenten is triviaal en wordt aan de lezer overgelaten. Zij P een deterministisch 1 Stop robuust T algoritme voor een onsamenhangende taak T. Om een beslissing van alle correcte processen op dezelfde waarde te bereiken simuleert protocol P eerst het protocol P. Wanneer echter een beslissing wordt genomen in P, wordt de waarde van die beslissing aan alle processen gezonden, en vervolgens gewacht tot N 2 beslissingen zijn ontvangen. Claim 2.11 Hierbij ontstaat geen deadlock. Bewijs. De terminatie van P impliceert dat elk correct proces beslist, dus ontvangt elk proces tenminste N 2 beslissingen van andere processen. Dan zijn (samen met de eigen beslissing) N 1 componenten van een vector in D N bekend. Claim 2.12 Deze partiële vector is uit te breiden tot een vector in D T. Bewijs. Als er in de run geen gebrekige processen zijn, beslist elk proces en de beslissingen vormen een vector d D T. De N 1 bekende waarden zijn een gedeelte van d en dus tot d uit te breiden. Als er een proces stopt voordat het beslist worden er slechts N 1 beslissingen genomen, en elk correct proces ontvangt precies deze N 1 beslissingen. Het is echter mogelijk, dat het stoppende proces niet defect, maar alleen traag was, en dat het alsnog het protocol afmaakt. Het beslist dan op een output, die samen met de N 1 eerdere beslissingen een vector in D T vormt. Merk op, dat alle mogelijke uitbreidingen van N 1 bekende beslissingen tot een vector in D T noodzakelijkerwijs in dezelfde samenhangscomponent van G T zitten. Een proces dat voldoende beslissingen (van protocol P ) heeft vernomen, geeft als output van P de samenhangscomponent van zo n uitbreiding. Er rest te bewijzen, dat het aldus geconstrueerde protocol P een deterministisch 1 Stop robuust beslisprotocol is. 1. Terminatie: Wegens claim 2.11 neemt elk correct proces een beslissing over de samenhangscomponent. 2. Consistentie: Alle correcte processen kennen uiteindelijk N 1 componenten van een vector d D T. Voor elke uitbreiding d D T van die componenten geldt, dat er een kant ( d, d ) in G T is, dus alle mogelijke uitbreidingen zitten in dezelfde samenhangscomponent. 3. Niet trivialiteit: Wegens de niet trivialiteit van P heeft P mogelijke output vectoren in zowel samenhangscomponent 0 als samenhangscomponent 1 van G T. De constructie van P impliceert dat zowel 0 als 1 de output van P kan zijn. Met stelling 2.3 volgt dat zo n protocol P niet bestaat. Opgave 2.2 Bewijs (met stelling 2.9) dat er geen deterministisch 1 Stop robuust algoritme is voor Electie, het berekenen van opspannende bomen, en Ranking. Opgave 2.3 Bewijs dat G Approx samenhangend is.

20 Hoofdstuk 3 Gerandomiseerde Consensus In stelling 2.3 werd bewezen, dat elk asynchroon consensusprotocol oneindige berekeningen heeft, waarin nooit een beslissing wordt genomen. Er werd in die stelling echter geen uitspraak gedaan over de kans waarmee een dergelijke berekening optreedt. In dit hoofdstuk zullen protocollen worden besproken, waarvoor de kans op een oneindig lange berekening zonder beslissing gelijk is aan nul. Dergelijke protocollen zijn practisch toepasbaar. De protocollen in dit hoofdstuk zijn ontleend aan een artikel van Gabriel Bracha en Sam Toueg [BT85]. De correctheidseisen voor een gerandomiseerd consensusprotocol zijn: 1. Convergentie: Voor elke initiële configuratie geldt: lim k Pr (Een correct proces heeft na k stappen nog niet beslist) = Consistentie: Er bestaat geen bereikbare configuratie waarin er correcte processen zijn die verschillend beslissen. 3. Niet trivialiteit: Er zijn zowel 0 besliste als 1 besliste configuraties bereikbaar. Merk op, dat de consistentie en niet trivialiteit dezelfde eisen zijn als in hoofdstuk 2 (waar deterministische protocollen werden bekeken), maar dat de terminatie is afgezwakt naar convergentie. In hoofdstuk 2 kon de onmogelijkheid van een protocol worden bewezen door (voor een verondersteld protocol) een oneindige run te construeren, maar nu zal er gekeken moeten worden naar inconsistente bereikbare configuraties. Om de kans op een beslissing van een proces te kunnen berekenen, is het noodzakelijk om een kansverdeling op de mogelijke runs van het protocol te definiëren. Dit kan op verschillende manieren, bijvoorbeeld door de aanname van gerandomiseerde stappen in het protocol of via aannamen op de berichtdoorgave. Bracha en Toueg kozen voor het laatste. In dit hoofdstuk worden de volgende aanvullende notaties gebruikt. Voor een configuratie C en S {1,.., N} is de subconfiguratie C S gedefinieerd als C, beperkt tot S. Schrijf C σ D als σ(c) = D, C D als D bereikbaar is uit C, en C S D S als C σ D geldt voor een σ waarin slechts stappen in S voorkomen. Schrijf F i voor een configuratie waarin alle processen al hebben beslist voor i (i = 0, 1) en FS i voor een configuratie waarin alle processen in S al hebben beslist voor i. Opgave 3.1 Laat zien dat de convergentie eis niet impliceert dat het verwachte aantal stappen begrensd is. 16

21 3.1. EEN STOP ROBUUST PROTOCOL Een Stop Robuust Protocol In deze sectie zal worden bewezen dat er geen t Stop robuust consensusprotocol bestaat, gerandomiseerd noch deterministisch, wanneer t N 2, en voor t < N 2 zal een gerandomiseerd protocol worden gegeven. Belangrijk in het bewijs van onmogelijkheid (voor t N 2 ) is, dat elke verzameling van tenminste N t processen zelfstandig, dus zonder communicatie met processen buiten die verzameling, tot een beslissing moet kunnen komen zoals geformaliseerd in het volgende lemma. Lemma 3.1 Voor elke bereikbare configuratie C van een t Stop robuust consensusprotocol en elke S die tenminste N t processen bevat, geldt C S F 0 S of C S F 1 S. Bewijs. Beschouw alle runs die het systeem in configuratie C brengen, en waarin vervolgens slechts processen in S worden geactiveerd. Deze runs zijn t Stop omdat ten hoogste t processen hierbij niet meer worden geactiveerd. Wegens de convergentie eis wordt er een besliste configuratie bereikt in tenminste één van deze runs. Lemma 3.2 Elk t Stop robuust consensusprotocol heeft een bivalente initiële configuratie. Bewijs. (Vergelijk lemma 2.4.) Wegens niet trivialiteit zijn er initiële configuraties D 0 en D 1 zodanig dat D 0 F 0 en D 1 F 1. Dus zijn er ook initiële configuraties C 0 en C 1, zodanig dat C 0 F 0, C 1 F 1, en C 0 en C 1 verschillen in de input van ten hoogste t processen. Zij S de verzameling van processen, waarin C 0 en C 1 overeenkomen, dan geldt CS 0 = C1 S. Uit lemma 3.1 volgt CS 0 F S 0 of C0 S F S 1. Als C0 S F S 0, dan ook C1 S F S 0, dus C1 is bivalent. Als CS 0 F S 1, dan is C0 bivalent. Stelling 3.3 Er is geen t Stop robuust consensusprotocol voor t N 2. Bewijs. Daar het aantal correcte processen ten hoogste de helft van het totale aantal processen bedraagt, kunnen er twee groepen van processen worden gevormd, die zo groot zijn dat ze volgens lemma 3.1 kunnen beslissen zonder interactie met de andere groep. Hieruit zal een inconsistentie worden afgeleid. De volgende claims hebben betrekking op een t Stop robuust consensusprotocol, waar t N 2. Claim 3.4 Voor een configuratie C, en S met S = N/2 geldt: C S en C S zijn beide 0 valent of beide 1 valent. ( S is het complement van S.) Bewijs. Volgens lemma 3.1 geldt C S σ i FS i en C S σ j F j S (voor zekere i, j). Als hierbij i en j ongelijk gekozen kunnen worden geldt (gebruik lemma 2.1) σ i (σ j (C)) = F, een configuratie waarin de processen in S en S verschillend beslist hebben, een tegenspraak met de consistentie. Claim 3.5 Er is geen bivalente configuratie. Bewijs. Zij C een bivalente configuratie, S een verzameling van N/2 processen, en veronderstel, zonder verlies van algemeenheid, dat C S en C S beide 1 valent zijn (zie claim 3.4). Aangezien C bivalent is, is er een reeks stappen σ 0 met σ 0 (C) = F 0. Daar C S en C S beide 1 valent en FS 0 en F 0 S beide 0 valent zijn, zijn er in de berekening die van C naar F 0 leidt opeenvolgende configuraties E en G,