mn1: Kapitel 7: Zufallszahlen

7
Zufallszahlen
7.1
Bedeutung
7.2
Lehmer-Generatoren für Zufallszahlen
7.2.1
7.2.2
7.2.3
7.2.4
7.2.5
Aufbau
Kombination von Generatoren
Berechnung von (a*s) mod m
Empfehlung von Park und Miller
Empfehlungen von Knuth
7.3
Tausworthe-Generatoren
7.3.1.
7.3.2
7.3.3
7.3.4
Aufbau
Golombs Gütekriterien
Implementation
Parallele Nutzung
7.4
Generator von Blum, Blum und Shub
7.5
Test von Zufallszahlen
7.5.1
7.5.2
7.5.3
7.5.4
Chi-Quadrat-Test
Empirische Tests
Tests für Bitfolgen
Tests nach FIBS 140-1
7.6
Anwendungen
7.6.1
7.6.2
7.6.3
Verschlüsselungsverfahren
Primzahltests
Buffons Nadelexperiment
Bedeutung der Zufallszahlen:
Zufallszahlen benötigt man in vielen Gebieten, z.B.
(i)
um Glücksspiele durchzuführen,
(ii)
um ausgesuchte Eigenschaften von Algorithmen zu
bestimmen, z. B. ihre Effizienz,
(iii)
um Simulationsexperimente durchzuführen,
(iv)
zur Nutzung in der numerischen Mathematik
(Stichwort: Monte Carlo Algorithmen),
(v)
um Nachrichten zwecks Geheimhaltung zu
verschlüsseln,
(vi)
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.
Beispielausgabe eines von Neumannschen MittelquadratZufallszahlen-Generators, hier für vierstellige Dezimalzahlen:
Form:
Startwert:
x := (x*x div 100) mod 10000
6239
Dies ist eine längste Folge für vierziffrige Startwerte, bis
periodische Wiederholung einsetzt, *-Zeichen kennzeichnen die Periode.
6239
9251
5810
7561
1687
8459
5546
7581
4715
2312
3453
9232
2298
2808
8848
2871
2426
8854
3933
4684
9398
3224
3941
5314
2385
6882
3619
971
9428
8871
6946
2469
959
9196
5664
808
6528
6147
7856
7167
3658
3809
5084
8470
7409
8932
7806
9336
1608
5856
2927
5673
1829
3452
9163
9605
2560
5536
6472
8867
6236
8876
7833
3558
6593
4676
8649
8052
8347
6724
2121
4986
8601
9772
4919
1965
8612
1665
7722
6292
5892
7156
2083
3388
4785
8962
3174
742
5505
3050
3025
1506
2680
1824
3269
6863
1007
140
196
384
1474
1726
9790
8441
2504
2700
2900
4100
8100 *
6100 *
2100 *
4100 *
Lehmer-Generator:
Form (L):
mit
xn+1 := (a * xn + c) mod m
m =
a =
c =
x0 =
Modul
Multiplikator
Addend
Startwert
(0
(1
(0
(0
<
<
≤
≤
(n ≥ 0)
m)
a < m)
c < m)
x0 < m)
Beispiel: xn+1 := (7 * xn + 6) mod 64
Periodenstruktur von xn+1 = (7 * xn + 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.
Es gilt:
x1 = (a ∗ x0 + c)
2
x2 = (a ∗ x0 + a ∗ c + c)
3
2
x3 = (a ∗ x0 + a ∗ c + a ∗ c + c)
4
3
2
x4 = (a ∗ x0 + a ∗ c + a ∗ c + a ∗ c + c)
...
allgemein:
an − 1
n
xn = ( a ∗ x0 +
∗ c ) modm
(n ≥ 0)
a−1
mod m
mod m
mod m
mod m
oder auch:
xn + k
ak − 1
∗ c) mod m
= (a ∗ xn +
a −1
k
(n ≥ 0, k ≥0)
Sei nun λ > 0 der kleinste Index mit xλ = x0 , dann muß
aλ − 1
λ
x 0 = (a ∗ x 0 +
∗ 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 xn+1 := (41*xn + 5) mod 64
erfüllt die Bedingungen des Satzes.
Spezialfälle:
e
(i)
Modul m = 2 , Addend c > 0:
e
Die volle Periode m = 2 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 , Addend c = 0:
e-2
Die maximale Periode ist 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.
e
(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 ≡ a*x + 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.
Zum Begriff primitives Element:
Betrachten wir die Rekursion
(R11)
xn+1 := a * xn mod 11
mit Startwert 1:
Für a = 2, 3, 4, ..., 10 erhält man die Zyklen:
a
a
a
a
a
a
a
a
a
=
=
=
=
=
=
=
=
=
2:
3:
4:
5:
6:
7:
8:
9:
10:
1,
1,
1,
1,
1,
1,
1,
1,
1,
2, 4,
3, 9,
4, 5,
5, 3,
6, 3,
7, 5,
8, 9,
9, 4,
10
8,
5,
9,
4,
7,
2,
6,
3,
5,
4
3
9
9,
3,
4,
5
10, 9, 7, 3, 6
10, 5, 8, 4, 2
10, 4, 6, 9, 8
10, 3, 2, 5, 7
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:
(p – 1) / q
a
≡ 1 (modulo p).
Zur Zufälligkeit der niederwertigen Bit:
Ausgabe des Generators xn+1 := (9 * xn + 1) mod 32
bei Startwert x0 = 1:
Nummer Zahl
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1
10
27
20
21
30
15
8
9
18
3
28
29
6
23
16
Bitkette
00001
01010
11011
10100
10101
11110
01111
01000
01001
10010
00011
11100
11101
00110
10111
10000
Nummer Zahl
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
17
26
11
4
5
14
31
24
25
2
19
12
13
22
7
0
Bitkette
10001
11010
01011
00100
00101
01110
11111
11000
11001
00010
10011
01100
01101
10110
00111
00000
Bem.: Sei xn+1 := (a*xn + c) mod m (n ≥ 0),
sei t ein Teiler von m, sei yn := xn mod t (n ≥ 0),
dann gilt: yn+1 := (a*yn + c) mod t (n ≥ 0).
Dies folgt aus: ∃ f mit xn+1 = a*xn + c – f*m,
bildet man auf beiden Seiten den Rest bezüglich t,
dann erhält man die Rekursion für yn.
Zweidimensionale Darstellung der Ausgabe
aller Punktpaare (xi, xi+1) des Generators
xn+1 := (31 * xn) mod 61
60:
:
:
:
:
:
55:
:
:
:
50:
:
:
:
:
45:
:
:
:
:
40:
:
:
:
:
35:
:
:
:
:
30:
:
:
:
:
25:
:
:
:
:
20:
:
:
:
:
15:
:
:
:
:
10:
:
:
:
:
5:
:
:
:
:
0:
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
------------------------------------------------------------0
5
0
5
0
5
0
5
0
5
0
5
0
*
Bemerkung: Die Verteilung der 60 Punktpaare im
(60, 60)-Quadrat macht nicht den Eindruck
einer gleichmäßigen, zufälligen Verteilung.
Zweidimensionale Darstellung der Ausgabe
aller Punktpaare (xi, xi+1) des Generators
xn+1 := (43 * xn) mod 61
60:
*
:
*
*
:
:
*
*
:
55:
*
:
*
:
*
*
:
:
*
50:
*
:
*
*
:
:
*
*
:
: *
45:
*
:
*
*
:
:
*
*
40:
:
*
:
*
:
*
:
*
35:
*
:
*
:
*
:
*
*
:
*
30:
:
*
:
*
:
*
:
*
25:
*
:
*
:
*
:
*
:
*
20:
*
:
*
*
:
:
*
:
*
:
15:
*
*
:
*
:
*
:
*
10:
*
:
*
*
:
:
*
*
:
*
5:
*
:
:
*
:
*
:
*
0: ------------------------------------------------------------0
5
0
5
0
5
0
5
0
5
0
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.
Kombinieren von Lehmer-Generatoren:
Lemma: Seien W1 und W2 zwei unabhängige
ganzzahlige Zufallsvariablen; W1 sei
gleichverteilt im Intervall [0, m) und der
Wertebereich von W2 liege im Inter-vall [a, b].
Dann gilt:
W = (W1 + W2) mod m
ist gleichverteilt in [0, m).
Beweis: Sei k ∈ [0, m), dann gilt für die
Wahrscheinlichkeit P (W = k):
P( W = k ) =
∞
∑ P( W1 + W2 = k + i ∗ m )
i = −∞
b
= ∑ P( W2 = j) ∗P ( W1 = (k − j) mod m )
j= a
b
1
∗ ∑ P(W2 = j)
m j= a
1
=
q.e.d.
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.
//
//
//
//
//
Zufallszahlengenerator von Brian Wichmann und
David Hill aus Byte 12,3; pp. 127–128; (3/1987);
programmiert für Rechner und Implementationen
von Hochsprachen, deren Ganzzahlen mittels 16 Bit
dargestellt werden.
#include <cmath>
static int x = 7;
static int y = 77;
static int z = 777;
// Zustand gen1
// Zustand gen2;
// Zustand gen3;
int gen1 () {
// x = (171 * x) mod 30269
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
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 30000
// initialisiert werden.
double random () {
int x = gen1 ();
int y = gen2 ();
int z = gen3 ();
double t = x/30269.0
+ y/30307.0
+ z/30323.0;
t -= floor (t);
return t;
}//random
// Der Generator besitzt eine Periode von
// 6.953.607.871.644, dies ist das kleinste gemeinsame
// Vielfache von 30269–1, 30307–1 und 30323–1.
Berechnung von
(171 * x) mod 30269
für 0 <= x < 30269 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 30269
(171* 177 * r + 171 * s) mod 30269
(30267 * r + 171 * s) mod 30269
((30269 – 2)* r + 171 * s) mod 30269
(171 * s – 2 * r) mod 30269
Bemerkungen:
(i)
Ist die Größe a negativ, dann wird sie durch eine
einmalige Addition von 30269 positiv.
(ii)
Analog zeigt man die Korrektheit der angegebenen
Berechnungen für y = (172 * y) mod 30307 und
z = (170 * z) mod 30323.
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:
2
(i)
Hinreichend für (4) ist: a ≤ 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.
Empfehlung von Park und Miller:
Bemerkung: Die Autoren nennen diesen Generator den
Minimalstandard.
// Private constants
int const m = 2147483647;
int const a = 48271;
// = 2^31 - 1
// vorher: 16807
// Der Multiplikator 48271 liefert gute Ergebnisse
// beim Spektraltest.
// Private global variable
static int s = 314156;
// Startwert austauschbar
double random () {
static int const q = m / a;
// m div a = 44488
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
119 Werte aus Park-Miller-Generator:
0.0615785
0.454093
0.529076
0.0323609
0.0915079
0.179958
0.745017
0.723199
0.549313
0.897723
0.96913
0.85832
0.951798
0.221517
0.838093
0.568722
0.800124
0.78123
0.773503
0.759348
0.476195
0.423786
0.59633
0.467971
0.405241
0.395446
0.55617
0.870495
0.661351
0.0788992
0.543289
0.082255
0.532985
0.695545
0.630638
0.549417
0.904053
0.566268
0.313281
0.39865
0.251371
0.923453
0.0142327
0.0243577
0.768212
0.353732
0.0177051
0.641809
0.785729
0.900474
0.803796
0.0484152
0.051372
0.776847
0.200312
0.277336
0.301639
0.435707
0.00678907
0.715382
0.214854
0.20778
0.743274
0.560187
0.801608
0.405263
0.44494
0.72122
0.0236372
0.991878
0.930624
0.158735
0.303485
0.544629
0.784409
0.227
0.534783
0.509807
0.870688
0.980321
0.0867625
0.110459
0.960339
0.511774
0.850218
0.852749
0.0610166
0.330844
0.18896
0.296276
0.536301
0.784664
0.495256
0.480233
0.349615
0.281214
0.490855
0.0570173
0.280507
0.356536
0.330721
0.25465
0.219507
0.840382
0.057848
0.382201
0.242333
0.64218
0.678683
0.685739
0.308739
0.132027
0.0531209
0.198086
0.800794
0.108526
0.65618
0.447911
0.0910482
Empfehlungen von Knuth für Lehmer-Generatoren:
xn+1 := (a ∗ xn + c) mod m
(n ≥ 0)
(i)
Wähle den Modul m groß, die Rekursionsformel ist
exakt auszuwerten.
(ii)
Ist m = 2 , dann gelte a mod 8 = 5, ist m = 10 ,
dann gelte a mod 200 = 21.
x
y
(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 x0, x1, x2, ... 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 xi (i ≥ 0) eine Folge von Zufallszahlen, die Ableitung
von Zufallszahlen aus dem Intervall [0, r) sollte nicht
mittels ri = xi mod r erfolgen, sondern eher mittels
((xi div u) ∗ r) div v oder auch mittels (xi div w) mod r
für sinnvoll gewählte u, v oder w.
Beispiel zu (vi):
8
m = 10
a = 31415821
c = 1
Der Startwert x = 1234567 liefert die folgenden 20
Zahlen:
35884508
80001069
63512650
43635651
1034472
87181513
6917174
209855
67115956
59939877
46594018
29158779
81642560
50941761
45000782
12172023
95775884
27860765
6163066
78267187
⇑ Hier Regelmäßigkeit in der letzten
Ziffer.
Eine einfache Erweiterung des Lehmer-Generators:
(T) xn := (a1*xn-1 + a2*xn-2 + ... + ak*xn-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
k
Periode der Länge p - 1, falls p eine
Primzahl ist und das zugeordnete Polynom
k
k-1
k-2
x - a1*x - a2*x - ... - ak im Körper
k
mit p Elementen primitiv ist.
Primitive Polynome zu bestimmen ist aufwendig, es
existieren aber umfangreiche Tabellenwerke, beispielsweise sind die folgenden Polynome für p = 2 primitiv:
5
2
x +x +1
5
3
x +x +1
5
4
3
2
x +x +x +x +1
5
4
2
x +x +x +x+1
32
7
5
3
2
x +x +x +x +x +x+1
64
4
3
x +x +x +x+1
So liefert der Generator xn := xn-1 + xn-3 + xn-4 + xn-5 mit
den Startwerten (x4, x3, x2, x1, x0) = (1, 1, 1, 0, 0) die
Bitfolge mit der Periode 31:
(B) 0 0 1 1 0 1 1 1 1 1 0 1 0 0 0 1 0 0 1 0 1 0 1 1 0 0 0 0 1 1 1
S. W. Golomb führte für maschinell erzeugte Bitketten
b0, b1, b2, b3, b4, ... 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
∑ ( 2∗ b i − 1)∗ ( 2∗ b i + t − 1) = 
i=0
k
p−1
( t = 0)
( 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:
15 0-Bit, 16 1-Bit
ad K2:
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.
Schieberegister zur Implementation der Rekursion:
xn := (xn-4 + xn-5 + xn-6 + xn-8) mod 2
8
4
3
(n ≥ 8)
2
beschreibendes Polynom: x + x + x + x + 1
7
0
6
1
5
0
4
1
3
1
⊕
2
0
1
1
⊕
0
0
⊕
: 1−Bit Schieberegister, ⊕ : Exklusives Oder
Folgezustände:
00101101
10010110
01001011
00100101
00010010
10001001
01000100
10100010
01010001
00101000
10010100
8
4
3
2
Bemerkung: Dem Polynom x + x + x + x + 1 läßt
sich ein weiteres Schieberegister zuordnen,
das bei der Programmierung in Hochsprachen einfacher zu nutzen ist.
Beispiel: Erzeugung einer Bitfolge
32
Primitives Polynom: x
7
5
3
2
+x +x +x +x +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 & 0x80000000) >> 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
//
//
//
//
//
//
//
//
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
Einige Beispielwerte des Generators (103, 250):
1819300605
1031285057
1934834310
455124156
1501855213
1104661026
144372488
2064976827
1453972417
1948531071
1700171956
190647411
1949347147
1336350827
1377025091
1131188961
406129345
1532409484
304225778
976411586
2117158018
1884439084
126172790
1676996747
2135738079
341210488
1489611118
210741831
1101452714
541835016
1148109169
36004216
885107139
206234496
1537131527
1629314416
1052679710
383226574
1917392911
555425406
891886653
1445586440
1130783474
2008889607
271449401
1452572210
1799383689
403840454
1582439978
129540647
1671612985
1775174694
815228250
696017821
1626624905
771542948
2131821843
300347862
443868223
1924308412
1128251553
1593618472
309005370
989139608
674722943
982183676
1617688801
430783668
2139809744
1287909855
650744332
558420571
688080882
344168785
1621645808
1256046690
932958997
1904092835
1702986752
1211428917
Zur Initialisierung paralleler Generatoren:
Beispiel: xn := (xn-10 + xn-7) mod 2 für n = 10, 11, 12,
Bild: Vierfache Parallelität
xn–10 xn–9
xn–8 xn–7 xn–6
xn–5
xn–4 xn–3 xn–2
xn–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
4
Addition modulo 2 , 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.
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
2
x0 := s mod n.
3. Bilde Folge
2
xi+1 := xi mod n
(i ≥ 0)
4. Die Folge
zi := xi mod 2
(i ≥ 0)
ist eine kryptographisch sichere Bitfolge.
Bemerkung: Die letzten log2 (n) Bit der Zahlen zi (i ≥ 0)
werden als kryptographisch sicher
angesehen.
Beispiel: Die ersten 200 Bit des Generators
x := (x*x) mod (223*251)
bei Startwert 321:
0111111110111111111010000011
1111011110001110110000101110
1101100011000100001101010000
0110011011011110000001010111
0101101001110101111111001111
0110100000010010110100100111
1010010011010100010111111101
0000
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 zi (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 = 2*p1 + 1, p1 = 2*p2 + 1,
q = 2*q1 + 1, q1 = 2*q2 + 1 mit p1, p2,
q1 und q2 prim. Selbst unter diesen zusätzlichen Bedingungen ist es schwierig, Anfangswerte zu finden, so daß die Folge
zi (i ≥ 0) eine hinreichend lange Periode
hat. So existieren nur zwei Zyklen der
Länge 110 für den Generator
x := (x * x) mod (23*47).
Chi-Quadrat Test:
Voraussetzungen:
1. Eine stochastische Quelle Q möge eine Folge
unabhängiger Ereignisse e0, e1, e2, ... , en, ... liefern.
2. Die Ereignisse mögen k > 0 (nichtüberlappenden)
Kategorien zuordbar sein; die Wahrscheinlichkeit,
mit der ein Ereignis e zur Kategorie Ks gehört, sei
ps > 0 (s = 1, ..., k).
3. Man kategorisiere n > 0 Ereignisse der Quelle Q,
wobei ks die Zahl der Ereignisse in Kategorie Ks ist.
Den Wert
(1)
2
(k s − n ∗ ps ) 2
k
χ = ∑
s=1
2
n ∗ ps
nennt man die χ -Statistik mit k−1 Freiheitsgraden.
Bemerkungen:
2
(i) Der Wert χ aus Zeile (1) läßt sich umformen zu:
(2)
1 k  ks 2 
χ = ∗∑
 −n
n s= 1  ps 
2
Dies folgt aus
und
k1 + k2 + ... + kk = n
p1 + p2 + ... + pk = 1
(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
k1 + k2 + ... + kk = n ist
n!
k
k
k
∗ p1 1 ∗ p 2 2 ∗ L ∗ p k k
k1 ! ∗ k 2 ! ∗ L ∗ k k !
Hieraus lassen sich Vertrauensintervalle für eine
Beobachtungskette der Länge n berechnen.
(v)
2
Die tabellierte χ –Statistik ist unabhängig von n,
daher ist sie für kleine n unzuverlässig.
Beispielwerte sind:
Freiheitsgrad
1
2
3
4
5
6
8
10
12
20
30
50
5%-Quantile
0.00393
0.1026
0.3518
0.7107
1.1455
1.635
2.733
3.940
5.226
10.85
18.49
34.76
95%-Quantile
3.841
5.991
7.815
9.488
11.07
12.59
15.51
18.31
21.03
31.41
43.77
67.50
(vi) Knuth gibt folgende Näherungsformel für
Freiheitsgrade k > 30:
χ 2 (k ) ≈ k +
2∗ k ∗ a +
2
2
 1 
∗ a2 − + O

 k
3
3
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 0.5.
1010100100
0110101000
1000101011
0011011000
1001100010
(4
(4
(5
(4
(4
1-Bit)
1-Bit)
1-Bit)
1-Bit)
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) 2 + ( 29 − 25) 2
25
25
=
32
= 1.28
25
Dieser Wert ist weder zu klein noch zu groß.
Unterteilt man nun die Folge in 5 Abschnitte der Länge 10,
dann ist:
2 2
2 2
8
2
χ (5) = + + 0 + + = = 1.6
5 5
5 5
5
Dieser Wert ist verhältnismäßig klein.
Einfache empirische Tests:
Ein Zahlengenerator ZG gibt vor, im Intervall [0, 1)
gleichverteilte und unabhängige Zahlen zu liefern. Sei
z0, z1, z2, z3, ... zn,
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 gi = zi ∗ d
(0 ≤ i ≤ n), und zähle, wie oft jede der Zahlen
0, 1, 2, ..., d-1 vorkommt. Anschließend führe man
2
einen χ -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 gi = zi ∗ d
(0 ≤ i ≤ n), nun zählt man das Auftreten der nicht
überlappenden Paare (z2*i, z2*i+1), die Plausibilität
der erhaltenen Kategorienwerte überprüft man in
2
2
einem χ -Test mit d –1 Freiheitsgraden und der
2
Basis-Wahrscheinlichkeit 1/d . In diesem Fall sollte
2
n größer als 5 ∗ d sein. Dieser Test ist verallgemeinerbar auf Tripel, Quadrupel, Quintupel, u.s.w.
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 Ik (k = 1, ..., m) im
Zahlbereich [1, n]; man führe folgende Schritte aus:
(a) Sortiere die Folge Ik (k = 1, ..., m) aufsteigend.
(b) Bilde die Folge der Differenzen D1 = I1 - Im + m,
D2 = I2-I1, D3 = I3-I2, ..., Dm = Im - Im-1
(c) Setze Y = m – Zahl der verschiedenen Differenzen; Y nähert sich asymptotisch einer Poisson3
Verteilung mit Parameter λ= m /(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
2
führt man einen χ -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.
Einfache Tests für Zufallsbitfolgen:
Sei b = b0, b1, b2, ..., bn-1
ein Abschnitt der Länge n einer Zufallsbitfolge.
(i) Monobittest:
Sei n0 die Zahl der 0-Bit, n1 die Zahl der 1-Bit, dann
folgt
2
n 0 − n1 )
(
x1 =
n
2
einer χ -Verteilung mit einem Freiheitsgrad.
(ii) Zweibittest
Sei nxy die Zahl der Bitpaare (x, y) aus {0, 1} ✕ {0, 1},
n0 und n1 seien wie oben definiert, dann folgt
x2 =
(
)
(
)
4
2
2
2
2
2
2
2
∗ n 00 + n 01 + n10 + n11 − ∗ n 0 + n1 + 1
n−1
n
2
einer χ -Verteilung mit zwei Freiheitsgraden, es gilt auch
n00 + n01 + n10 + n11 = n-1.
(iii) Pokertest:
m
Sei m eine positive Ganzzahl mit n/m ≥ 5 ∗2 , sei
k = n/m, teile die Folge b in nichtüberlappende Teilabschnitte der Länge m; sei ni die Zahl der Teilabschnitte
m
der Form i (0 ≤ i < 2 ), dann folgt
2m  2 − 1 2 
x3 =
∗  ∑ ni  − k

k  i=0
m
2
m
einer χ -Verteilung mit 2 - 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
ei =
n−i+3
2i + 2
Die Statistik
k
x4 = ∑
i =1
(Bi −e i )2 + k (Ci −e i )2
ei
2
∑
i =1
ei
folgt einer χ -Verteilung mit 2k – 2 Freiheitsgraden.
Hierbei sind Bi die Zahl der 1-Bit Läufe und Ci die Zahl
der 0-Bit Läufe für i = 1, 2, ... , n.
Ergänzung zu (iv):
Herleitung der Formel für
ei =
n−i+3
2i + 2
(0 ≤ i < n)
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:
011 ... 10
i-mal
Die Wahrscheinlichkeit des Auftretens dieses Musters an
einer gültigen Position innerhalb der betrachteten Bitkette
–(i+2)
ist 2
.
Daraus ergibt sich ei zu
–(i+2)
ei
= 2
* Zahl gültiger Positionen
–(i+1)
* Zahl der Randpositionen
+ 2
–(i+2)
–(i+1)
= 2
* (n – (i + 1)) + 2
* 2
–(i+2)
= (n – i + 3) * 2
en
=
–n
2
q.e.d.
Aus FIPS PUB 140-1 (11/01/1994)
Bemerkung: FIPS PUB 140-1 steht für Federal
Information Processing Standards
Publication 140-1.
Test für Generatoren von Zufallszahlen, Testobjekt ist
jeweils eine Bitkette der Länge 20000.
(i) Monobittest:
Der Test gilt als bestanden, falls
9645 < Zahl der 1-Bit < 10346
(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äß:
15
16
2

2
∗  ∑ ( f ( i ) )  − 5000
χ =

5000  i = 0
Der Test gilt als bestanden, falls 1.03 < χ2 < 57.4
(iii) Lauftest:
Sei Bi die Zahl der 1-Bit Läufe der Länge i (0<i<6),
sei B6 die Zahl der 1-Bit Läufe der Länge > 5,
sei Ci die Zahl der 0-Bit Läufe der Länge i (0<i<6),
sei C6 die Zahl der 0-Bit Läufe der Länge > 5.
Der Test gilt als bestanden, falls sämtliche B- und CWerte innerhalb folgender Grenzen liegen.
Lauflänge
1
2
3
4
5
6
untere Grenze obere Grenze
2267
2733
1079
1421
502
748
223
402
90
223
90
223
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.
Vernams Verschlüsselungsalgorithmus:
Sei N eine Bitkette, die eine Nachricht repräsentiert,
sei Z eine zufällige Bitkette, sei ⊗ die exklusive OderOperation 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:
01011010011001010110100101110100
Zufällige Bitkette:
11011000101100011110000101110001
Verschlüsselte Nachricht:
10000010110101001000100000000101
Entschlüsselte Nachricht:
01011010011001010110100101110100
Probabilistischer Primzahltest:
Satz von Fermat:
p prim ==> ∀a (0 < a < p) a
p–1
≡ 1 (mod p)
66
Beispiele: 2
≡ 1 mod 67
340
≡ 1 mod 341, 341 ist nicht prim
2
340
3
≡ 56 mod 341
Bemerkung: Man nennt eine Zahl n eine
Carmichaelsche Zahl, falls für alle a,
die teilerfremd zu n sind, gilt:
n-1
a
≡ 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
2
x ≡ 1 (mod p)
Beweis:
==>
==>
2
x ≡ 1 (mod p)
(x–1) * (x+1) ≡ 0 (mod p)
p | x–1 oder p | x+1.
Millers Test:
Sei n ungerade, n > 1,
wähle b ( 0 < b < n),
k
sei k := n–1, r := b mod n
Falls r ≠ 1 ==> n nicht prim
Wiederhole
k := k / 2
k
r := b mod n
bis (k ungerade) oder (r ≠ 1 und r ≠ n–1)
r ≠ (1 oder n–1) ==> n nicht prim
Beispiele:
n = 25, b = 7
24
7
12
7
6
7
3
7
≡
≡
≡
≡
1
1
1
18
(mod 25)
(mod 25)
(mod 25)
(mod 25)
n = 341, b = 2
340
2
≡ 1 (mod 341)
170
≡ 1 (mod 341)
2
85
2
≡ 1 (mod 341)
Bemerkung: Die Wahrscheinlichkeit, daß die
Nichtprimheit einer ungeraden Zahl n
durch einen Millertest nicht entdeckt wird,
ist kleiner als 1/4.
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
π
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ϕ = l
2
R = π∗a/2
Damit
P = l ∗ 2 / (a ∗ π) oder
π = 2 ∗ l / (a ∗ P)
Im Jahre 1901 berichtete Lazzarini, daß er π mittels
Nadelwurfs zu 3.1415929 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:
π ≈
2 ∗ 5 ∗ 3408
2 ∗ 5 ∗16 ∗ 213
315
=
=
= 3.1415929
6 ∗1808
2 ∗ 3 ∗ 16 ∗ 113
113
Ein Experiment mit dem Generator von Park und Miller
ergibt:
Versuche
Versuche
Versuche
Versuche
Versuche
=
=
=
=
=
1000,
5000,
10000,
15000,
20000,
Treffer
Treffer
Treffer
Treffer
Treffer
=
=
=
=
=
312,
1585,
3212,
4851,
6416,
π
π
π
π
π
=
=
=
=
=
3.22061
3.14169
3.14416
3.1348
3.14639