7 Zufallszahlen. 7.1 Bedeutung

Transkript

1 7 Zufallszahlen 7.1 Bedeutung 7.2 Lehmer-Generatoren für Zufallszahlen Aufbau Kombination von Generatoren Berechnung von (as) mod m Empfehlung von Park und Miller Empfehlungen von Knuth 7.3 Tausworthe-Generatoren Aufbau Golombs Gütekriterien Implementation Parallele Nutzung 7.4 Generator von Blum, Blum und Shub 7.5 Test von Zufallszahlen Chi-Quadrat-Test Empirische Tests Tests für Bitfolgen Tests nach FIBS Anwendungen Verschlüsselungsverfahren Primzahltests Buffons Nadelexperiment

2 Bedeutung der Zufallszahlen: Zufallszahlen benötigt man in vielen Gebieten, z.b. (i) (ii) (iii) (iv) (v) (vi) um Glücksspiele durchzuführen, um ausgesuchte Eigenschaften von Algorithmen zu bestimmen, z. B. ihre Effizienz, um Simulationsexperimente durchzuführen, zur Nutzung in der numerischen Mathematik (Stichwort: Monte Carlo Algorithmen), um Nachrichten zwecks Geheimhaltung zu verschlüsseln, zur Nutzung in der genetischen Programmierung, (vii) als neutrale Datenquelle in probabilistischen Testverfahren, (viii) zur Nutzung in probabilistischen Algorithmen, (ix) als Hilfsmittel zur Erzeugung von Kompositionsvielfältigkeiten in der bildenden Kunst, u. s. w.

3 Beispielausgabe eines von Neumannschen Mittelquadrat- Zufallszahlen-Generators, hier für vierstellige Dezimalzahlen: Form: x := (xx div 100) mod Startwert: 6239 Dies ist eine längste Folge für vierziffrige Startwerte, bis periodische Wiederholung einsetzt, -Zeichen kennzeichnen die Periode

4 Lehmer-Generator: Form (L): x n+1 := (a x n + c) mod m (n 0) mit m = Modul (0 < m) a = Multiplikator (1 < a < m) c = Addend (0 c < m) x 0 = Startwert (0 x 0 < m) Beispiel: x n+1 := (7 x n + 6) mod 64 Periodenstruktur von x n+1 = (7 x n + 6) mod 64: 1) 0, 6, 48, 22, 32, 38, 16, 54 2) 1, 13, 33, 45 3) 2, 20, 18, 4, 34, 52, 50, 36 4) 3, 27 5) 5, 41, 37, 9 6) 7, 55 7) 8, 62, 56, 14, 40, 30, 24, 46 8) 10, 12, 26, 60, 42, 44, 58, 28 9) 11, 19 10) 15, 47 11) 17, 61, 49, 29 12) 21, 25, 53, 57 13) 23, 39 14) 31 15) 35, 59 16) 43, 51 17) 63 Bemerkung: Verfügt man über Lehmer-Generatoren, die Zahlenfolgen der Periode m erzeugen, dann entfällt das Startwertwahlproblem weitgehend.

5 Es gilt: x 1 = (a x 0 + c) x 2 = (a 2 x 0 + a c + c) x 3 = (a 3 x 0 + a 2 c + a c + c) x 4 = (a 4 x 0 + a 3 c + a 2 c + a c + c)... allgemein: n n a xn = ( 1 a x0 + c modm n a ) ( 1 0) oder auch: k k a 1 xn+ k = (a xn + c) modm (n 0, a 1 mod m mod m mod m mod m k 0) Sei nun λ > 0 der kleinste Index mit x λ = x 0, dann muß λ λ a 1 x0 = (a x0+ c) mod m gelten, diese Formel kann a 1 man benutzen, um den folgenden Satz herzuleiten. Satz: Ein linearer Generator der Form L besitzt eine Periode der Maximallänge m genau dann, falls gilt: (i) c und m sind teilerfremd, (ii) jede Primzahl p, die m teilt, teilt auch a-1, (iii) a-1 ist ein Vielfaches von 4, falls m ein Vielfaches von 4 ist. Bemerkung: Der Generator x n+1 := (41x n + 5) mod 64 erfüllt die Bedingungen des Satzes.

6 Spezialfälle: (i) Modul m = 2 e, Addend c > 0: Die volle Periode m = 2 e erreicht man nur, falls für den Multiplikator a 1 (mod 4) gilt und der Addend c ungerade ist. Die niederwertigen Bit sind nur geringfügig zufällig. (ii) Modul m = 2 e, Addend c = 0: Die maximale Periode ist 2 e-2, man erreicht sie, falls für den Multiplikator a 3 (mod 8) oder a 5 (mod 8) gilt. Die niederwertigen Bit sind nur geringfügig zufällig. (iii) Modul m ist eine Primzahl größer als 2, c = 0: Die Periode ist in diesem Fall maximal m 1, der Zufallswert 0 ist zu meiden. Eine maximale Periode erhält man, falls man als Multiplikator a ein primitives Element modulo m wählt. Wählt man c 0, dann ist die maximale Periode auch nur m 1, denn die Kongruenz x ax + c (mod m) hat genau eine Lösung. Der Grad der Zufälligkeit der niederwertigen Bit ist durch a bestimmt, er ist im Einzelfall zu ermitteln.

7 Zum Begriff primitives Element: Betrachten wir die Rekursion (R11) x n+1 := a x n mod 11 mit Startwert 1: Für a = 2, 3, 4,..., 10 erhält man die Zyklen: a = 2: 1, 2, 4, 8, 5, 10, 9, 7, 3, 6 a = 3: 1, 3, 9, 5, 4 a = 4: 1, 4, 5, 9, 3 a = 5: 1, 5, 3, 4, 9 a = 6: 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 a = 7: 1, 7, 5, 2, 3, 10, 4, 6, 9, 8 a = 8: 1, 8, 9, 6, 4, 10, 3, 2, 5, 7 a = 9: 1, 9, 4, 3, 5 a = 10: 1, 10 Nur die Multiplikatoren 2, 6, 7 und 8 führen zum Auftreten aller Zahlen 0 bei der Rekursion R11. Man nennt sie primitive Elemente modulo 11. Satz: Sei p eine ungerade Primzahl und sei a 0 (modulo p). a ist genau dann ein primitives Element modulo p, falls gilt: für jeden Primfaktor q von p 1 ist: a (p 1) / q 1 (modulo p).

8 Zur Zufälligkeit der niederwertigen Bit: Ausgabe des Generators x n+1 := (9 x n + 1) mod 32 bei Startwert x 0 = 1: Nummer Zahl Bitkette Nummer Zahl Bitkette Bem.: Sei x n+1 := (ax n + c) mod m (n 0), sei t ein Teiler von m, sei y n := x n mod t (n 0), dann gilt: y n+1 := (ay n + c) mod t (n 0). Dies folgt aus: f mit x n+1 = ax n + c fm, bildet man auf beiden Seiten den Rest bezüglich t, dann erhält man die Rekursion für y n.

9 Zweidimensionale Darstellung der Ausgabe aller Punktpaare (x i, x i+1 ) des Generators x n+1 := (31 x n ) mod : 40: 35 30: : 25 : 20: 15 : 10: 5 : 0: : Bemerkung: Die Verteilung der 60 Punktpaare im (60, 60)-Quadrat macht nicht den Eindruck einer gleichmäßigen, zufälligen Verteilung.

10 Zweidimensionale Darstellung der Ausgabe aller Punktpaare (x i, x i+1 ) des Generators x n+1 := (43 x n ) mod 61 60: 55 50: : 45 : 40: 35 : 30: 25 20: : 15 : 10: 5: : : 0: Bemerkung: Die Verteilung der 60 Punktpaare im (60, 60)-Quadrat ist gleichmäßiger als im Fall des Multiplikators 31; der Spektraltest ermöglicht eine Unterscheidung zwischen guten und weniger guten Multiplikatoren.

11 Kombinieren von Lehmer-Generatoren: Lemma: Seien W 1 und W 2 zwei unabhängige ganzzahlige Zufallsvariablen; W 1 sei gleichverteilt im Intervall [0, m) und der Wertebereich von W 2 liege im Inter-vall [a, b]. Dann gilt: W = (W 1 + W 2 ) mod m ist gleichverteilt in [0, m). Beweis: Sei k [0, m), dann gilt für die Wahrscheinlichkeit P (W = k): P(W = k) = = = = b i= j= a 1 m 1 m P(W P(W = j) P (W b j= a 2 1 P(W q.e.d. + W 2 2 = = k + i m) j) 1 = (k j) mod m) Bemerkung: Verfügt man über mehrere Lehmer-Generatoren L1, L2,..., Ln, dann gewinnt man durch Addition oder Subtraktion dieser Generatoren einen neuen Generator. Seine Periode wird bestimmt durch das kleinste gemeinsame Vielfache der Perioden der benutzten Generatoren.

12 // Zufallszahlengenerator von Brian Wichmann und // David Hill aus Byte 12,3; pp ; (3/1987); // programmiert für Rechner und Implementationen // von Hochsprachen, deren Ganzzahlen mittels 16 Bit // dargestellt werden. #include <cmath> static int x = 7; // Zustand gen1 static int y = 77; // Zustand gen2; static int z = 777; // Zustand gen3; int gen1 () { // x = (171 x) mod x = 171 (x % 177) - 2 (x / 177); if (x < 0) x += 30269; return x ; }//gen1 int gen2 () { // y = (172 y) mod 30307; y = 172 (y % 176) - 35 (y / 176); if (y < 0) y += 30307; return y; }//gen2

13 int gen3 () { // z = (170 z) mod 30323; z = 170 (z % 178) - 63 (z / 178); if (z < 0) z += 30323; return z; }//gen3 // Vor dem ersten Aufruf von random sollten die // Zustandsvariablen mit Zahlen zwischen 1 und // initialisiert werden. double random () { int x = gen1 (); int y = gen2 (); int z = gen3 (); double t = x/ y/ z/ ; t -= floor (t); return t; }//random // Der Generator besitzt eine Periode von // , dies ist das kleinste gemeinsame // Vielfache von , und

14 Berechnung von (171 x) mod für 0 <= x < auf einem Rechner mit vorzeichenbehafteten 16-Bit Ganzahlen ohne Unter- oder Überlauf. Sei x = 177 r + s mit 0 r < 172 und 0 s < 176 Dann a = (171 x) mod = ( r s) mod = (30267 r s) mod = (( ) r s) mod = (171 s 2 r) mod Bemerkungen: (i) (ii) Ist die Größe a negativ, dann wird sie durch eine einmalige Addition von positiv. Analog zeigt man die Korrektheit der angegebenen Berechnungen für y = (172 y) mod und z = (170 z) mod

15 Berechnung von (a s) mod m durch angenäherte Faktorisierung: Vor.: (i) 0 < m, m ganzzahlig (ii) 0 < a < m, a ganzzahlig (iii) 0 < s < m, s ganzzahlig Zerlege m gemäß m = m/a a + m mod a = q a + r Nun ist s = s/q q + s mod q, damit (a s) mod m = (a s/q q + a s mod q) mod m = (a q s/q + a s mod q) mod m = ((m r) s/q + a s mod q) mod m (1) = (a s mod q r s/q ) mod m Nun (2) 0 a s mod q a q m (3) 0 r s/q r m/q m, falls r q Gilt (4) r = m mod a m div a = q, dann läßt sich (a s) mod m ohne Unterlauf oder Überlauf berechnen, wie aus (1), (2) und (3) folgt, falls alle Zahlen zwischen 0 und m darstellbar sind. Bemerkungen: (i) Hinreichend für (4) ist: a 2 m. (ii) Gilt (4) nicht, dann wiederholt man obiges Verfahren zur Berechnung von (r s/q ) mod m, hierbei ist r < a, womit nach Bemerkung (i) das Verfahren konvergiert.

16 Empfehlung von Park und Miller: Bemerkung: Die Autoren nennen diesen Generator den Minimalstandard. // Private constants int const m = ; // = 2^31-1 int const a = 48271; // vorher: // Der Multiplikator liefert gute Ergebnisse // beim Spektraltest. // Private global variable static int s = ; // Startwert austauschbar double random () { static int const q = m / a; // m div a = static int const r = m % a; // m mod a = 3399 // hier: m mod a <= m div a int t = a (s % q) - r (s / q); s = (t > 0)? t : t + m; return double (s) / double (m); }// random

17 119 Werte aus Park-Miller-Generator:

18 Empfehlungen von Knuth für Lehmer-Generatoren: x n+1 := (a x n + c) mod m (n 0) (i) Wähle den Modul m groß, die Rekursionsformel ist exakt auszuwerten. (ii) Ist m = 2 x, dann gelte a mod 8 = 5, ist m = 10 y, dann gelte a mod 200 = 21. (iii) Für a möge gelten m < a < m m. (iv) Das Ziffernmuster von a sollte "recht unregelmäßig" sein. (v) Die Additionskonstante c sollte ungerade sein und nicht ein Vielfaches von 5. (vi) Man sollte daran denken, daß die niederwertigen Ziffern der Zahlen x 0, x 1, x 2,... nicht immer sehr zufällig sind (Gilt nur eingeschränkt für Primzahlmodul). Die Bemerkung (vi) hat Auswirkungen auf die Gewinnung kleiner Zufallszahlen aus großen Zufallszahlen. Sei x i (i 0) eine Folge von Zufallszahlen, die Ableitung von Zufallszahlen aus dem Intervall [0, r) sollte nicht mittels r i = x i mod r erfolgen, sondern eher mittels ((x i div u) r) div v oder auch mittels (x i div w) mod r für sinnvoll gewählte u, v oder w.

19 Beispiel zu (vi): m = 10 8 a = c = 1 Der Startwert x = liefert die folgenden 20 Zahlen: Hier Regelmäßigkeit in der letzten Ziffer.

20 Eine einfache Erweiterung des Lehmer-Generators: (T) x n := (a 1 x n-1 + a 2 x n a k x n-k ) mod p Wählt man als Modul 2, dann verfügt man über einen Generator für zufällige Bitketten, traditionell nennt man Generatoren dieser Art Tausworthe-Generatoren. Bemerkung: Ein Bitgenerator der Form T hat eine Periode der Länge p k - 1, falls p eine Primzahl ist und das zugeordnete Polynom x k - a 1 x k-1 - a 2 x k a k im Körper mit p k Elementen primitiv ist. Primitive Polynome zu bestimmen ist aufwendig, es existieren aber umfangreiche Tabellenwerke, beispielsweise sind die folgenden Polynome für p = 2 primitiv: x 5 + x x 5 + x x 5 + x 4 + x 3 + x x 5 + x 4 + x 2 + x + 1 x 32 + x 7 + x 5 + x 3 + x 2 + x + 1 x 64 + x 4 + x 3 + x + 1 So liefert der Generator x n := x n-1 + x n-3 + x n-4 + x n-5 mit den Startwerten (x 4, x 3, x 2, x 1, x 0 ) = (1, 1, 1, 0, 0) die Bitfolge mit der Periode 31: (B)

21 S. W. Golomb führte für maschinell erzeugte Bitketten b 0, b 1, b 2, b 3, b 4,... folgende Mindestanforderungen ein: K1: In einer Periode differieren die Zahl der 0-Bit und die Zahl der 1-Bit höchstens um 1. K2: In einer Periode haben mindestens die Hälfte der Läufe eine Länge von 1, mindestens ein Viertel der Läufe eine Länge von 2, mindestens ein Achtel der Läufe eine Länge von 3,... K3: Die Autokorrelation ist zweiwertig, genauer p 1 ( 2 b 1) ( 2 b 1) = i= 0 i i+ t p ( t = 0) k ( 1 t p 1) Bemerkung: Eine Folge von 1-Bit, die durch 0-Bit begrenzt wird, nennt man einen 1-Lauf; analog definiert man den 0-Lauf. Für die obige Bitfolge B erhält man: ad K1: ad K2: 15 0-Bit, 16 1-Bit 16 Läufe: 8 Läufe der Länge 1 4 Läufe der Länge 2 2 Läufe der Länge 3 1 Lauf der Länge 4 1 Lauf der Länge 5 ad K3: Die Autokorrelationswerte sind 31 und 1.

22 Schieberegister zur Implementation der Rekursion: x n := (x n-4 + x n-5 + x n-6 + x n-8 ) mod 2 (n 8) beschreibendes Polynom: x 8 + x 4 + x 3 + x : 1 Bit Schieberegister, : Exklusives Oder Folgezustände: Bemerkung: Dem Polynom x 8 + x 4 + x 3 + x läßt sich ein weiteres Schieberegister zuordnen, das bei der Programmierung in Hochsprachen einfacher zu nutzen ist.

23 Beispiel: Erzeugung einer Bitfolge Primitives Polynom: x 32 + x 7 + x 5 + x 3 + x 2 + x + 1 Imitation eines Schieberegisters: unsigned sr32 () { static unsigned sr = Startwert; sr = (((( sr >> 7) ^( sr >> 5) ^( sr >> 3) ^( sr >> 2) ^( sr >> 1) ^( sr )) & 1) << 31) (sr >> 1); return (sr & 0x ) >> 31; }//sr32 Zyklische Nutzung einer Tabelle: static unsigned bitw [32] = {Startwerte}; unsigned b32 () { static unsigned n = 31; n = (n+1)%32; bitw [n] = ( bitw [(n-25)%32] + bitw [(n-27)%32] + bitw [(n-29)%32] + bitw [(n-30)%32] + bitw [(n-31)%32] + bitw [(n-32)%32]) % 2; return bitw [n]; }//b32

24 // Beispiel eines Tausworthe-Generators (auch verzögerter // Fibonacci-Generator genannt) zur Erzeugung von // Zufallszahlen; ein primitives Polynoms wird mit // verschiedenen Anfangswerten parallel genutzt. // Hier: Trinom x^q + x^p + 1; // formelmäßig: x[k] := x [k-q+p] xor x [k-q] für k >= q // oder : x[k] := x [k-p] xor x [k-q] für k >= q // erprobte Paare (p, q) = (103, 250), (27, 98), (37, 532) // Wichtig ist ein guter Zufallszahlengenerator zur // Bereitstellung von Anfangswerten. int irandom () { / z. B. Parks Empfehlung / } // Die folgende Beschreibung läßt sich vereinfachen. const int pp = 103; const int qq = 250; static int p = pp-1; static int q = qq-1; static int table [qq]; void init_table () { for (int i = 0; i < qq; ++i) table [i] = irandom (); }//init_table int trand () { p = (p+1) % qq; q = (q+1) % qq; table [q] ^= table [p] ; return table [q]; }//trand

25 Einige Beispielwerte des Generators (103, 250):

26 Zur Initialisierung paralleler Generatoren: Beispiel: x n := (x n-10 + x n-7 ) mod 2 für n = 10, 11, 12, Bild: Vierfache Parallelität x n 10 x n 9 x n 8 x n 7 x n 6 x n 5 x n 4 x n 3 x n 2 x n 1 Bemerkung: Nutzt man obigen Generator parallel, um Zufallszahlen im Intervall [0, 16) zu erzeugen, dann muß man bei der Initialisierung darauf achten, daß keine Reihe nur 0 Bit enthält. Ersetzt man die parallele Anwendung der Modulo 2 Addition durch eine Addition modulo 2 4, dann muß man nur darauf achten, daß die das niederwertigste Zahlbit repräsentierende Reihe mindestens ein 1 Bit enthält. Dies sicherzustellen ist trivial, ein erwünschter Nebeneffekt ist die Erhöhung der Periode.

27 Generator von Blum, Blum, Shub: 1. Wähle zwei Primzahlen p und q mit p mod 4 = 3 und q mod 4 = 3 und berechne n = p q. 2. Wähle s aus [1, n 1] mit s teilerfremd zu n und berechne x 0 := s 2 mod n. 3. Bilde Folge x i+1 := x i 2 mod n (i 0) 4. Die Folge z i := x i mod 2 (i 0) ist eine kryptographisch sichere Bitfolge. Bemerkung: Die letzten log 2 (n) Bit der Zahlen z i (i 0) werden als kryptographisch sicher angesehen.

28 Beispiel: Die ersten 200 Bit des Generators x := (xx) mod (223251) bei Startwert 321: Bemerkung: Es ist wichtig, daß die Primzahlen p und q hinreichend groß sind, wählt man z. B. p = 7, q = 11, dann hat die Folge z i (i 0) höchstens eine Periode von 4, dies ist bedeutend kleiner als 77. Daher sollte man an p und q die zusätzlichen Forderungen stellen, p = 2p1 + 1, p1 = 2p2 + 1, q = 2q1 + 1, q1 = 2q2 + 1 mit p1, p2, q1 und q2 prim. Selbst unter diesen zusätzlichen Bedingungen ist es schwierig, Anfangswerte zu finden, so daß die Folge z i (i 0) eine hinreichend lange Periode hat. So existieren nur zwei Zyklen der Länge 110 für den Generator x := (x x) mod (2347).

29 Chi-Quadrat Test: Voraussetzungen: 1. Eine stochastische Quelle Q möge eine Folge unabhängiger Ereignisse e 0, e 1, e 2,..., e n,... liefern. 2. Die Ereignisse mögen k > 0 (nichtüberlappenden) Kategorien zuordbar sein; die Wahrscheinlichkeit, mit der ein Ereignis e zur Kategorie K s gehört, sei p s > 0 (s = 1,..., k). 3. Man kategorisiere n > 0 Ereignisse der Quelle Q, wobei k s die Zahl der Ereignisse in Kategorie K s ist. Den Wert (1) ( k n p ) 2 χ 2 k s s = s= 1 n ps nennt man die χ 2 -Statistik mit k 1 Freiheitsgraden. Bemerkungen: (i) Der Wert χ 2 aus Zeile (1) läßt sich umformen zu: (2) χ k k s = n s= 1 p s n Dies folgt aus k 1 + k k k = n und p 1 + p p k = 1

30 (ii) Den Chi-Quadrat Test führte Karl Pearson im Jahre 1900 ein. Ian Hacking hält ihn für eine der 20 wichtigsten Erfindungen des zwanzigsten Jahrhunderts. (iii) Wie aus Zeile (1) ersichtlich, erhalten "seltene" Ereignisse eine hohe Gewichtung. (iv) Die Wahrscheinlichkeit einer Beobachtungskette mit k 1 + k k k = n ist n! k! k! L k! 1 2 k k k p p L p k k k Hieraus lassen sich Vertrauensintervalle für eine Beobachtungskette der Länge n berechnen. (v) Die tabellierte χ 2 Statistik ist unabhängig von n, daher ist sie für kleine n unzuverlässig. Beispielwerte sind: Freiheitsgrad 5%-Quantile 95%-Quantile

31 (vi) Knuth gibt folgende Näherungsformel für Freiheitsgrade k > 30: k k k a a 3 O k ( ) χ mit a = 1.64 für 5%-Quantile und a = 1.64 für 95%-Quantile. (vii) Ein Beispiel: Eine Bitkette der Länge 50, die Wahrscheinlichkeit für das Auftreten eines 1-Bit sei (4 1-Bit) (4 1-Bit) (5 1-Bit) (4 1-Bit) (4 1-Bit) Man hat 21 1-Bit und 29 0-Bit, die Hypothese für gleiche 1-Bit- und 0-Bit-Wahrscheinlichkeiten ergibt: χ 2 (1) = ( 21 25) ( 29 25) = = Dieser Wert ist weder zu klein noch zu groß. Unterteilt man nun die Folge in 5 Abschnitte der Länge 10, dann ist: χ (5) = = = Dieser Wert ist verhältnismäßig klein. 16.

32 Einfache empirische Tests: Ein Zahlengenerator ZG gibt vor, im Intervall [0, 1) gleichverteilte und unabhängige Zahlen zu liefern. Sei z 0, z 1, z 2, z 3,... z n, die von ZG gelieferte Zahlenfolge. Einfache Test erlauben die Widerlegung der Gleichverteilung und Unabhängigkeit. 1) Test auf Gleichverteilung: Man wähle eine hinreichend große Zahl n und eine ganze Zahl d. Man bilde die Folge g i = z i d (0 i n), und zähle, wie oft jede der Zahlen 0, 1, 2,..., d-1 vorkommt. Anschließend führe man einen χ 2 -Test mit d 1 Freiheitsgraden und der einheitlichen Kategorien-Wahrscheinlichkeit 1/d durch. 2) Paartest: Wie im Test auf Gleichverteilung wähle man eine hinreichend große Zahl n und eine positive Ganzzahl d. Man bilde wiederum die Folge g i = z i d (0 i n), nun zählt man das Auftreten der nicht überlappenden Paare (z 2i, z 2i+1 ), die Plausibilität der erhaltenen Kategorienwerte überprüft man in einem χ 2 -Test mit d 2 1 Freiheitsgraden und der Basis-Wahrscheinlichkeit 1/d 2. In diesem Fall sollte n größer als 5 d 2 sein. Dieser Test ist verallgemeinerbar auf Tripel, Quadrupel, Quintupel, u.s.w.

33 3) Geburstagtest ("Birthday Spacings" Test): Dieser Test stammt von George Marsaglia, er untersucht die Abstände in der geordneten Folge der Zufallszahlen, seine Bedeutung liegt darin, daß die meisten Tausworthe-Generatoren ihn nicht bestehen. Zum Ablauf: Ein Generator produziere die nichtnegativen Ganzzahlen I k (k = 1,..., m) im Zahlbereich [1, n]; man führe folgende Schritte aus: (a) Sortiere die Folge I k (k = 1,..., m) aufsteigend. (b) Bilde die Folge der Differenzen D 1 = I 1 - I m + m, D 2 = I 2 -I 1, D 3 = I 3 -I 2,..., D m = I m - I m-1 (c) Setze Y = m Zahl der verschiedenen Differenzen; Y nähert sich asymptotisch einer Poisson- Verteilung mit Parameter λ= m 3 /(4 n), daher wähle man n und m so, daß m³ 4 n. (d) Auf den Kategorien Y = 0, Y = 1, Y = 2; Y > 2 führt man einen χ 2 -Test aus, die Kategorienwahrscheinlichkeiten entnimmt man der zugehörigen Poisson-Verteilung. Die Zahl der Probanden sollte mehrere hundert sein. Bemerkung: Die Zahl dieser Tests läßt sich beliebig verlängern, jede Eigenschaft, für die man die Wahrscheinlichkeitsverteilung kennt, eignet sich als Testgrundlage. Zu fragen ist aber, ob ein weiterer Test neue Erkenntnisse bringt oder nur alte bestätigt.

34 Einfache Tests für Zufallsbitfolgen: Sei b = b 0, b 1, b 2,..., b n-1 ein Abschnitt der Länge n einer Zufallsbitfolge. (i) Monobittest: Sei n 0 die Zahl der 0-Bit, n 1 die Zahl der 1-Bit, dann folgt x 1 = ( n n ) n einer χ 2 -Verteilung mit einem Freiheitsgrad. (ii) Zweibittest Sei n xy die Zahl der Bitpaare (x, y) aus {0, 1} {0, 1}, n 0 und n 1 seien wie oben definiert, dann folgt 4 2 n n + + x 2 = ( n 2 2 ) ( ) 00 n n n11 n0 n1 1 einer χ 2 -Verteilung mit zwei Freiheitsgraden, es gilt auch n 00 + n 01 + n 10 + n 11 = n-1.

35 (iii) Pokertest: Sei m eine positive Ganzzahl mit n/m 5 2 m, sei k = n/m, teile die Folge b in nichtüberlappende Teilabschnitte der Länge m; sei n i die Zahl der Teilabschnitte der Form i (0 i < 2 m ), dann folgt m x 3 = 2 m ni k i= 0 k einer χ 2 -Verteilung mit 2 m - 1 Freiheitsgraden. (iv) Lauftest: Die erwartete Zahl von 1 Läufen oder 0 Läufen der Länge i (1 i < n) in einer Bitfolge der Länge n ist e i = n i+ 3 i+ 2 2 Die Statistik x 4 k = 2 ( B e ) k ( C e ) i e + i= 1 i i= 1 i i e i i 2 folgt einer χ 2 -Verteilung mit 2k 2 Freiheitsgraden. Hierbei sind B i die Zahl der 1-Bit Läufe und C i die Zahl der 0-Bit Läufe für i = 1, 2,..., n.

36 Ergänzung zu (iv): n i + 3 Herleitung der Formel für e i = (0 i < n) i+ 2 2 Man betrachte eine Bitkette der Länge n, wobei die Erzeugung eines 1 Bit oder eines 0 Bit ein unabhängiges Ereignis der Wahrscheinlichkeit 1/2 sei. Man wähle i mit 0 i < n. Ein 1-Bit-Lauf der Länge i wird beschrieben durch das Muster: i-mal Die Wahrscheinlichkeit des Auftretens dieses Musters an einer gültigen Position innerhalb der betrachteten Bitkette ist 2 (i+2). Daraus ergibt sich ei zu e i = 2 (i+2) Zahl gültiger Positionen + 2 (i+1) Zahl der Randpositionen = 2 (i+2) (n (i + 1)) + 2 (i+1) 2 = (n i + 3) 2 (i+2) e n = 2 n q.e.d.

37 Aus FIPS PUB (11/01/1994) Bemerkung: FIPS PUB steht für Federal Information Processing Standards Publication Test für Generatoren von Zufallszahlen, Testobjekt ist jeweils eine Bitkette der Länge (i) Monobittest: Der Test gilt als bestanden, falls 9645 < Zahl der 1-Bit < (ii) Pokertest: Unterteile die Bitkette in 5000 nichtüberlappende 4-Bit Abschnitte. Bestimme die Häufigkeit f (i) (0 i 15) für jedes 4-Bit-Musters; berechne χ 2 gemäß: χ = ( f() i ) i= 0 Der Test gilt als bestanden, falls 1.03 < χ 2 < 57.4 (iii) Lauftest: Sei B i die Zahl der 1-Bit Läufe der Länge i (0<i<6), sei B 6 die Zahl der 1-Bit Läufe der Länge > 5, sei C i die Zahl der 0-Bit Läufe der Länge i (0<i<6), sei C 6 die Zahl der 0-Bit Läufe der Länge > 5.

38 Der Test gilt als bestanden, falls sämtliche B- und C- Werte innerhalb folgender Grenzen liegen. Lauflänge untere Grenze obere Grenze Ferner darf kein Lauf einer Länge größer als 33 existieren. (iv) Wiederholungstest: Produziert ein Zufallszahlengenerator Bitblöcke der Länge n, wobei n > 15 ist, dann dürfen nie zwei aufeinanderfolgende Bitblöcke gleich sein; ist die Produktionslänge l 15, dann sind für diesen Test jeweils n aufeinanderfolgend produzierte Bits zu einem Block der Länge n, wobei n > 15 zu wählen ist, zusammenzufassen.

39 Vernams Verschlüsselungsalgorithmus: Sei N eine Bitkette, die eine Nachricht repräsentiert, sei Z eine zufällige Bitkette, sei die exklusive Oder- Operation für Bitketten, dann Verschlüsselte Nachricht VS = N Z, Entschlüsselte Nachricht N = VS Z. Bemerkung: Die Güte der Verschlüsselung wird bestimmt von der Güte der Bitkette Z, ist Z "wahrhaft zufällig", dann ist dies Verschlüsselungsverfahren sicher. Beispiel: Nachricht = "Zeit" Nachricht als Bitkette: Zufällige Bitkette: Verschlüsselte Nachricht: Entschlüsselte Nachricht:

40 Probabilistischer Primzahltest: Satz von Fermat: p prim ==> a (0 < a < p) a p 1 1 (mod p) Beispiele: mod mod 341, 341 ist nicht prim mod 341 Bemerkung: Man nennt eine Zahl n eine Carmichaelsche Zahl, falls für alle a, die teilerfremd zu n sind, gilt: a n-1 1 (mod n). Satz: Sei p prim und sei 0 < x < p, dann gilt x = 1 und x = p 1 sind die einzigen Lösungen von x 2 1 (mod p) Beweis: x 2 1 (mod p) ==> (x 1) (x+1) 0 (mod p) ==> p x 1 oder p x+1.

41 Millers Test: Sei n ungerade, n > 1, wähle b ( 0 < b < n), sei k := n 1, r := b k mod n Falls r 1 ==> n nicht prim Wiederhole k := k / 2 r := b k mod n bis (k ungerade) oder (r 1 und r n 1) r (1 oder n 1) ==> n nicht prim Beispiele: n = 25, b = (mod 25) (mod 25) (mod 25) (mod 25) n = 341, b = (mod 341) (mod 341) (mod 341) Bemerkung: Die Wahrscheinlichkeit, daß die Nichtprimheit einer ungeraden Zahl n durch einen Millertest nicht entdeckt wird, ist kleiner als 1/4.

42 Buffons Nadelexperiment zur Bestimmung von π: Gegeben sei eine Schar paralleler Linien im Abstand a. Man werfe mehrmals eine Nadel der Länge l (l a) auf diese Schar und zähle, wie oft die Nadel eine Linie schneidet. Bild 1: a x ϕ Zur Beschreibung der Lage einer Nadel verwende man die Koordinaten des Nadelmittelpunkts und den Winkel ϕ zwischen Nadel und den parallelen Linien. Die Nadel schneidet eine Linie, falls für den kleinsten Abstand x des Nadelmittelpunktes zu einer Linie gilt: x (l / 2) sin (ϕ). Bild 2: f (x) = (l / 2) sin (ϕ) a / 2 0 π

43 Die Wahrscheinlichkeit P, daß eine geworfene Nadel eine Linie schneidet, läßt sich als Quotient zweier Flächen berechnen, der Fläche F unterhalb von f und der Rechteckfläche R. Es gilt: F = π 0 l sin( ϕ) dϕ = 2 R = π a / 2 l Damit P = l 2 / (a π) oder π = 2 l / (a P) Im Jahre 1901 berichtete Lazzarini, daß er π mittels Nadelwurfs zu bestimmt habe. Er gab an, daß er 3408 Experimente durchführte, wovon 1808 erfolgreich waren. Bei einem Verhältnis l / a = 5 / 6 erhielt er: π = = = Ein Experiment mit dem Generator von Park und Miller ergibt: Versuche = 1000, Treffer = 312, π = Versuche = 5000, Treffer = 1585, π = Versuche = 10000, Treffer = 3212, π = Versuche = 15000, Treffer = 4851, π = Versuche = 20000, Treffer = 6416, π =