Übung 3: ggt Berechnung verteilt

Transkript

1 Übung 3: ggt Berechnung verteilt Übungsgegenstand ist eine verteilte Fassung des Euklidischen Algorithmus zur Berechnung des größten gemeinsamen Teilers (ggt) einer Zahlenmenge. Euklidischer Algorithmus zur ggt-berechnung zweier Zahlen Der Euklidische Algorithmus basiert auf einem Satz von Euklid: (E0) x,y ganze Zahlen x > y > 0 ggt(x,y) = ggt(y, mod(x, y)). Der darauf basierende euklidische Algorithmus berechnet den ggt zweier Zahlen durch wiederholte entsprechende Ersetzung ((x, y) (y, mod(x, y)), Abbruchbedingung y = 0). ggt über Zahlenmenge Satz (E0) lässt sich auf eine Zahlenmenge übertragen. Man kann in einer Zahlenmenge ein Element durch seinen Modulus mit einer anderen, kleineren Zahl der Menge ersetzen, ohne dass sich der ggt verändert: (S0) x 1.., x j,.., x k,.., x n ganze Zahlen i 1..n : x i > 0 x j < x k ggt(x 1.., x j,.., x k,.., x n ) = ggt(x 1.., x j,.., mod(x k, x j ).., x n ). Verteilte Berechnung des ggt einer Zahlenmenge Die Funktion md(x,y) entspreche der Funktion mod(x,y) mit der Ausnahme, dass sie bei restloser Teilbarkeit den Teiler y statt der 0 liefere: md(x,y)::=if mod(x, y)=0 then y else mod(x, y) (entspricht auch: md(x, y) ::= mod(x-1, y)+1) Eine verteilte und auf eine Zahlenmenge der Kardinalität n erweiterte Fassung des Euklidischen Algorithmus ergibt sich dadurch, dass die Ersetzung ((x 1, x 2,..,x j,..,x k,.., x n ) (x 1, x 2,.., md(x j, x k ),..,x k,.., x n )) fortwährend für verschiedene Paare x i und x j angewendet wird. Der Zahlenvektor konvergiert, weil die Funktion md verwendet wird, dabei zum Wert (g, g, g,, g) mit g = ggt(x 1.., x n ). Der Algorithmus kann damit folgendermaßen skizziert werden: Es gibt n Stationen, jede Station i verwaltet einen variablen Zahlenwert M i und kennt eine eigene Konstante c i. Berechnet werden soll ggt(c 1, c 2,.., c n ). Initial gilt M i = c i. Stationen senden ihren aktuellen Wert M i an Nachbarstationen. Eine Station j, die einen Wert M k empfängt, der kleiner als der eigene Wert M j ist, berechnet M j neu (M j =md(m j, M k )) und sendet den neuen Wert M j an Nachbarn weiter.

2 : Ueb3.doc Spezifikation von NTS-Prozess und Stationsprozessen Zur kompositionalen Spezifikation des Algorithmus geben wir zunächst zwei Prozesstypen an, und setzen im Prozesstyp Algo dann das Algorithmus-entsprechende Gesamtsystem aus Instanzen dieser Typen zusammen. const n ; // Anzahl der Stationen, Adressen 1..n c 1,.., c n // Die Zahlenmenge Nachb 1,.., Nachb n // Die Netztopologie (Nachbarstationsmengen) process NTS ; // Nachrichtentransportsystem var b : bag of <dst, z> ; // Der Puffer der im Transfer befindlichen Nachrichten Init ::= b = {} ; actions send ( m : <dst, z>) ::= b = b {m} ; recv ( i : 1..n ; m : <dst, z>) ::= i = dst m b b = b \ {m} ; end ; process Station (c : card ; i : 1..n; Nachb : set of 1..n ); // Stationsprozess var M : card ; // Zahlenmerker ts : set of 1..n ; // Weitergabeziel-Merker Init ::= M = c ts = Nachb ; actions recvgre ( m : <dst, z>) ::= // Empfange nicht-aktualisierende Zahl z M M = M ts = ts ; recvlth ( m : <dst, z>) ::= // Empfange aktualisierende Zahl z < M M = mod(m-1, z)+1 ts =Nachb ; send (m : <dst,z> ) ::= // Sende M an Nachbarn z = M dst ts M = M ts = ts \ {dst} ; end ; process Algo ( n : card ; c : array [1..n] of card ; Nachb : array [1..n] of set of 1..n ) ; processes T : NTS ; // Das Transportsystem S : array [i: 1..n] of Station(c i, i, Nachb i ) ; // Die Stationsprozesse S 1,.. S n. actions recvgre ( i : 1..n ; m : <dst, z>) ::= // S i empfängt nicht-aktualisierende Zahl S i.recvgre(m) T.recv(i,m) j 1..n, j i: S j.stutter ; recvlth ( i : 1..n ; m : <dst, z>) ::= // S i empfängt aktualisierende Zahl S i.recvlth(m) T.recv(i,m) j 1..n, j i: S j.stutter ; send ( i : 1..n ; m : <dst,z> ) ::= // S i sendet sein M an Nachbarn S i.send(m) T.send(m) j 1..n, j i: S j.stutter ; end ;

3 : Ueb3.doc Spezifikation des Gesamtsystems als einfacher Prozess Zur Verifikation verwenden wir die expandierte und syntaktisch leicht vereinfachte Version Algo f des Prozesstyps Algo. Bitte zunächst das blau Geschriebene ignorieren. Es handelt sich um Hilfsvariablen-Historieninformation, welche Informationen aus dem vergangenen Ablauf speichert und später den Safety-Beweis unterstützt (Wir bemerken, dass die blauen Teile der Spezifikation keinen Einfluss auf die schwarzen Teile haben. Sie kommen weder in einem Guard einer Aktion noch in einem Effekt auf schwarze Zustandskomponenten vor). process Algo f ( n : card ; c : array [1..n] of card ; Nachb : array [1..n] of set of 1..n ) ; var b : bag of <D, dst, z> ; // Der Puffer der im Transfer befindlichen Nachrichten // mit D: set of 1 n; Stationsnummernmenge // dst: 1..n ; Zielstationsnummer // z: card ; Nachrichteninhalt, Zahl M : array [1..n] of card ; // Die Zahlenmerker der Stationen ts : array [1..n] of set of 1..n ; // Die Weitergabeziel-Merker der Stationen Init ::= b = {} i 1..n: ( M i =c i ts i = Nachb i ) ; actions recvgre ( i : 1..n ; m : <D, dst, z>) ::= // S i empfängt nicht-aktualisierende Zahl z M i i = dst m b M = M ts = ts b = b \ {m} ; recvlth ( i : 1..n ; m : <D, dst, z>) ::= // S i empfängt aktualisierende Zahl z < M i i = dst m b M = M außer M i = mod(m i -1, z)+1 ts = ts außer ts i =Nachb i b = b \{m}\{<e,j,v>: <E,j,v> b i E} {<E D,j,v>: <E,j,v> b i E} ; send ( i : 1..n ; m : <D, dst, z> ) ::= // S i sendet sein M an einen Nachbarn z = M i dst ts i M = M D={i} ts = ts außer ts i = ts i \ {dst} b = b {m} ; end ; Interessierende Safety-Eigenschaften Die korrektheitsrelevante Safety-Eigenschaft ist, dass der Vektor M bei Terminierung den Wert <g, g,.., g> mit g = ggt(c 1, c 2,.., c n ) besitzt. Eine Eigenschaft, die nicht besagt, dass die Terminierung tatsächlich immer eintreten muss (dies wäre nämlich keine Safety- sondern eine Liveness-Eigenschaft). Vorbereitend beweisen wir eine Formel als Invariante, die auch über die Zwischenzustände, und nicht nur über Terminierungszustände, etwas aussagt: ( ggt(m 1, M 2,.., M n ) = ggt(c 1, c 2,.., c n )). Anmerkung Der Beweis wurde in Zusammenarbeit mit Martin Schuster erarbeitet, der auch entdeckte, dass die vorherige Fassung fehlerhaft war.

4 : Ueb3.doc Der Beweis ist entgegen der ersten Vermutung nicht einfach. Denn der Algorithmus lässt es zu, dass ein in einer Nachricht enthaltener z-wert schon veraltet ist, weil die sendende Station zwischenzeitlich eine Nachricht empfing und ihren Wert M k auf M k =md(m k,z e ) änderte. Wenn nun die Nachricht mit dem veralteten z-wert empfangen wird und beim Empfänger dst die Aktualisierung hervorruft, wird dort M dst =md(m dst,z) gesetzt, ohne dass die Zahl z noch in der Menge M enthalten sein muss. Nun kann mod(x,y) aber gegenüber x neue Primfaktoren enthalten. Der Satz ggt(x,y) = ggt(y, mod(x, y)) gilt nur deshalb, weil die unter Umständen in mod(x,y) gegenüber x neu hinzukommenden Primfaktoren garantiert keine Primfaktoren von y sind, y sie also sozusagen wegschneidet. Wenn y aber plötzlich fehlt, können neue Faktoren eingeführt und ein zu großer ggt-wert berechnet werden. Beweis per Induktion über möglichen Ablauf, 1. Versuch Induktionsstart Es gilt Init ggt(m 1, M 2,.., M n ) = ggt(c 1, c 2,.., c n ) da M i = c i. Induktionsschritte Kritisch ist nur die Aktion recvlth, da sich nur hier ein M i ändert. Es ist zu beweisen: ggt(m 1, M 2,.., M n ) = ggt(c 1, c 2,.., c n ) z < M i i = dst m b // Induktionsvoraussetzung (IV) // Aktion recvlth M = M außer M i = mod(m i -1, z)+1 ts = ts außer ts i =Nachb i b = b \ {m} ggt(m 1, M 2,.., M n ) = ggt(c 1, c 2,.., c n ) // Induktionsbehauptung (IB) Dies lässt sich allerdings so nicht beweisen, weil wir nichts über den Wert z wissen. Es müsste sichergestellt sein, dass z der Wert eines M k mit k i ist, oder falls es ein veralteter Wert ist, dass dann wenigstens die aktuellen M-s ohne M i im Schnitt nicht mehr Primfaktoren als z haben. Die zu beweisende Invariante ggt(m 1, M 2,.., M n ) = ggt(c 1, c 2,.., c n ) ist also nicht induktiv. Sie muss verschärft werden. Eine geeignete Verschärfung zu finden, ist hier allerdings wegen der o.g. Komplikationen sehr schwierig. Vorabüberlegung und Einführung von Historieninformation Wie oben gesagt, kann an einer Station i ein z-wert eintreffen, der nicht mehr direkt einem M j entspricht, weil dieses schon aktualisiert wurde. Wir dürfen nur dann M i gemäß M i =mod(m i,z) verändern, ohne dass dabei möglicherweise der ggt der Menge M ein anderer als der von M ist, wenn sichergestellt ist, dass die u.u. in M i gegenüber M i dazukommenden Primfaktoren durch die anderen M-Werte ausgeschlossen werden. Es dort also je neuem Primfaktor mindestens ein M j mit j i gibt, das diesen Primfaktor nicht enthält. Der Algorithmus stellt, wenn er korrekt ist und davon gehen wir aus, dies implizit sicher, und die Idee ist nun, je Nachricht eine Hilfsvariablen-Historieninformation einzuführen, welche mitaufzeichnet, welche M-Werte jeweils gerade notwendig sind, um sicherzustellen, dass man M i =mod(m i,z) durchführen kann, ohne dadurch den ggt von M gegenüber M zu verändern.

5 : Ueb3.doc Dies ist der blau gefärbte Teil der Spezifikation. Eine Nachricht für Wert z= M i wird beim Senden mit der einelementigen Menge {i}, d.h. der Absenderadresse, versehen. Dies besagt, dass gegenwärtig schon der Wert M i ausreicht um sicherzustellen, dass für ein k i durch eine Modulo-Bildung mit z gemäß M k =mod(m k,z) sich keine ggt-verändernden neuen Faktoren von M k durchsetzen können, denn es gilt M i =z. Wenn nun irgendwann später eine Station k eine Nachricht <D,k,z> empfängt und ihren Wert verändert zu M k =mod(m k,z), dann muss man bedenken, dass z und damit die Wertemenge {M j : j D} nötig ist, um sicherzustellen, dass mit M k =mod(m k,z) der ggt von M gegenüber M nicht verändert wird. Für jede Nachricht <E,j,v> b mit k E gilt aber, dass M k benötigt wird, um bei einer Modulo- Bildung mit v zusätzliche Faktoren zu verhindern. Deshalb wird in jeder solchen Nachricht das E um D erweitert, die Nachricht lautet dann <E D,j,v>. Anmerkung 1: Es sei PF(x) die Primfaktorzerlegung einer natürlichen Zahl x (eine Vielfachmenge). Es sei PF(M), die Primfaktorzerlegung einer nichtleeren Zahlenmenge M N definiert als: (PF(x): x M). ggt(m)=ggt(m,x) ist dann gleichbedeutend mit: PF(M) PF(x) für eine nichtleere Menge M N. Anmerkung 2: Es seien M und N nichtleere Zahlenmengen mit M, N N. Dann ist ggt(m)=ggt(n) gleichbedeutend zu PF(M)=PF(N). Verschärfung der Invarianten Nach den Vorüberlegungen wird die Invariante folgendermaßen verschärft: (1) ggt(m 1,..., M n ) = ggt(c 1,..., c n ) ( <D,j,u> b (2) ggt({m i : i D}) = ggt({m i : i D} {u}) (3) (i D u M i ) ) Die verschärfte Invariante wird per Induktion über dem Algorithmus-Ablauf bewiesen: Induktionsstart: Init impliziert, dass b leer ist, weshalb die Verschärfungen (2) und (3) trivialerweise gelten. Induktionsschritt recvgre: M wird nicht verändert. Die Menge {x: <*, x> b} wird allenfalls kleiner. Deshalb kann IB aus IV gefolgert werden. Induktionsschritt recvlth: Station i empfängt eine Nachricht <D,i,z>, deren Wert z gemäß Guard der Aktion kleiner als M i ist: z< M i (*). Also ist i nach IV(3) nicht in D enthalten, alle gemeinsamen Primfaktoren der M-s aus D sind deshalb nach IV(2) und Anmerkung 1 auch Primfaktoren von z, weshalb M i =mod(m i,z) höchstens solche neuen Primfaktoren einführt, welche von den anderen M-s weggeschnitten werden. Es gilt deshalb PF({M k : k D }, M i )= PF({M k : k D }, M i ) (**)

6 : Ueb3.doc und mit Anmerkung 2 gilt ggt({m k : k D }, M i )=ggt({m k : k D }, M i ). Ergänzen beider Mengen um die fehlenden M-s führt zusammen mit IV(1) zu IB(1). Die Aktion verändert den Historienteil der Nachrichten in b. Bei jeder Nachricht <E,j,v>, deren Historienteil E die Stationsnummer i enthält, ist zu beachten, dass diese das alte M i benötigte, dieses sich aber zu M i verändert, welches wiederum die M k -s der Stationen k aus D benötigt. Da aber jede solche Nachricht <E,j,v> aus b in b zu <E D,j,v> aktualisiert wird, gilt IB(2) im Folgezustand der Aktion. Genauer folgt IB(2), was nach Anmerkung 1 gleichbedeutend zu PF(E') PF(v) ist, zusammen mit der aus IV(2) bekannten Tatsache PF(E) PF(v) aus: PF(E') = PF({M k ': k D}) PF({M k ' : k E}) = PF({M k ': k D}) PF({M k ': k E}\{M i '}) PF(M i ') = PF({M k ': k D}, M i ') PF({M k ': k E}\{M i '}) = (nach (**)) PF({M k ': k D}, M i ) PF({M k ': k E}\{M i '})= PF({M k ': k D}) PF({M k ': k E}\{M i '}, M i ) = PF({M k ': k D}) PF(E) PF(v). IB(3) gilt wegen der Transitivität von. Der Wert z der empfangenen Nachricht <D,i,z> ist laut IV(3) größer gleich jedem M-Wert der Stationen aus D, kurz z M k (k D). Der Wert v ist laut IV(3) größer gleich jedem M-Wert der Stationen aus E, kurz v M h (h E). Da sich auch i in E befindet, gilt v M i. Wegen (*) gilt v M i >z M k (k D), so dass v auch größer gleich jedem M-Wert der Stationen aus D sein muss. Der Wechsel von M i zu M i stört nicht, da M i kleiner als M i sein muss. Induktionsschritt send: M wird nicht verändert. b wird um ein neues Element größer, dessen z-wert direkt dem M i entspricht. Partielle Korrektheit Die Safety-Eigenschaft der partiellen Korrektheit (wenn Algorithmus terminierte, gilt dass das gewünschte Ergebnis berechnet wurde) lautet formal: P ::= ( k, l : M k = M l ) m : M m = ggt(c 1,.., c n ) Wenn alle Merker M den gleichen Wert enthalten, ist es der gesuchte ggt. Die oben bewiesene Invariante gilt für alle erreichbaren Zustände, also auch, wenn ein Zustand mit k, l : M k = M l vorliegt. Es gilt dann also <M 1,.., M k > = <g,.., g> und ggt(<g,.., g>)=ggt(<c 1,.., c n >). Der größte gemeinsame Teiler einer einelementigen Zahlenmenge {g} ist ferner natürlich g selber. Im Fazit lässt sich daraus P ableiten, also die partielle Korrektheit beweisen.

7 : Ueb3.doc Terminierung Als letztes soll die Liveness-Eigenschaft der Terminierung bewiesen werden. Die entsprechende Leads-To-Formel ist: Init ~> ( k, l : M k = M l ). Lattice Wir definieren die Funktion L als Abbildung der Zustände auf Vektoren: L ::= <M 1 -ggt(c 1,..,c n ), M 2 -ggt(c 1,..,c n )..,.., M n -ggt(c 1,..,c n )> L gibt wieder, wie weit der aktuelle Zustand der M i vom Ziel <g,g,.., g> entfernt ist. Der Bildbereich von L ist ein wohlfundierter Lattice mit der Halbordnung < Vektorvergleich und dem Minimum <0,0,..,0>. Da wir in ganzen Zahlen rechnen, gibt es für jeden möglich L-Wert nur endlich viele Schritte, in welchen der Wert vermindert werden kann. Dann muss das Minimum erreicht sein. Lebendige Lattice-Schritte Gelingt es uns jetzt nachzuweisen, dass die Schritte im Lattice lebendig sind, sind wir fertig: L = X <0,0,..,0> ~> L < X Beweis-Skizze: X <0,0,..,0> i,j: M i M j Dies können wir aus unseren Safety-Betrachtungen schließen. i,j: M i M j k,l: M k < M l k ist Nachbar von l Dies gilt, da das Netz zusammenhängend ist. Hilfreich ist außerdem noch folgende vermutete Invariante: F::= k,l: M k < M l k ist Nachbar von l <l,m k > b l ts k F lässt sich als Invariante beweisen: Init F F folgt direkt aus der Initialisierung F recvgre F Es wird zwar eine Nachricht gelöscht. Es ist jedoch keine Nachricht, welche von einer Station mit kleinerem M an eine Station mit größerem M gerichtet ist. F recvlth F Wenn <l,mk> empfangen wird, wird M l aktualisiert, und es gilt M k M l, so dass die linke Seite von F nicht mehr auf k und l zutrifft. Für die anderen Stationen o, p mit o,p sind Nachbarn und M o <M p hat sich nichts geändert, deshalb gilt für sie F wegen der Induktionsvoraussetzung F. Dadurch dass M k kleiner geworden ist, kann es aber sein, dass es neue direkte Nachbarnpaare o,p mit o,p sind Nachbarn und M o <M p gibt, nämlich solche mit o=k. Die Aktion aktualisierte aber ts k : ts k =Nachbarn(k). Damit gilt hier die rechte Seite von F. F send F Wenn l aus ts k entfernt wird, sendet k an l und es gibt <l,m k > b Mit der nun bewiesenen Invariante F lässt sich aus k,l: M k < M l k ist Nachbar von l folgern, dass auch gilt k,l: M k < M l k ist Nachbar von l ( <l,m k > b l ts k )

8 : Ueb3.doc Damit ist nachgewiesen: L = X <0,0,..,0> k,l: M k < M l k ist Nachbar von l ( <l,m k > b l ts k ) Jetzt werden zwei Leads-To Schritte transitiv verbunden: Schritt 1: Schon da oder Send schaltet k,l: M k < M l k ist Nachbar von l ( <l,m k > b l ts k ) ~> k,l: M k < M l k ist Nachbar von l <l,m k > b Schritt 2: Recvlth schaltet k,l: M k < M l k ist Nachbar von l <l,m k > b L = X ~> L <X Die Schritte lassen sich wie folgt beweisen. Schritt 1: Fall a: Es gelte <l,m k > b, damit greift die Schon da Regel (P Q / P~> Q) Fall b: Es gelte <l,m k > b, damit muss gelten l ts k, damit greift die Ein-Weak-Fairer-Schritt-Regel mit der Aktion send. Schritt 2: Es greift die Ein-Weak-Fairer-Schritt-Regel mit der Aktion recvlth. Die einzige Regel-Prämisse die nicht offensichtlich gilt, ist die Stabilität von Enabled(<recvlth>), bis recvlth feuert. Sie ist gegeben, da alle anderen Aktionen kein l ts i entfernen. Die transitive Verbindung der Schritte (P~>R, R~>Q / P~>Q) sowie zu Beginn die Schon da -Regel (P=>Q / P~>Q) führen zum gewünschten Ziel. Der Liveness-Beweis gelingt natürlich nur, wenn die beiden Aktionen recvlth und send weak fair ausgeführt werden. Die Spezifikation muss um diese beiden Fairness-Annahmen ergänzt werden. ===