_____________________________________________________________________________________
Inhalt....: Roulettestrategien II
Kategorie.: Arbeitsblatt
Mathematik: Stochastik, Programmierung
MuPAD.....: 3.1.0
Datum.....: 2005-07-04
Autoren...: Thorsten Fraas <thorstenfraas@gmx.de>
Funktionen: contains, for, has, if, begin, stats::binomialRandom
Funktionen: op, plot::Polygon2d, AxesTitles
_____________________________________________________________________________________
Empirische Untersuchung von Roulettestrategien II
Zur Einführung bitte die Einleitung in Notebook "roulette1.mnb" lesen.
Aufbau dieses Notebooks:
1. Grundlegende Prozeduren für das gesamte Notebook
2. Progressionsspiele
a) Einfache Martingalstrategie
b) Supermartingalstrategie
Vorbemerkung:
In vielen Casinos gibt es die Sonderregel, dass beim Auftauchen der Null der Spieler
nach dem Setzen auf die Einfachen Chancen die Hälfte seines Einsatzes zurückerhält.
Je nach Casino gibt es weitere solcher Sonderregeln für das Verhalten beim
Erscheinen der Null.
Ich habe es unterlassen derartige Sonderregeln in die Prozeduren
zu integrieren, da die 100%-ige Modellierung des Spiels den theoretischen Teil meiner Arbeit
(siehe Anmerkung am Ende des Dokuments) mathematisch nicht mehr handhabbar hätte
werden lassen. Ich musste also vereinfachte Annahmen machen, um den Umfang einer
Staatsexamensarbeit einhalten zu können.
In Notebook 5 habe ich später nach Beenden der Arbeit versucht, die Sonderregel in die
Prozeduren zu integrieren. Dies ist mir für die Einfache Martingalstrategie und die
Supermartingalstrategie gelungen. Somit ist Notebook 5 als Anhang zu verstehen, der
den Leser dazu motivieren kann, auch die anderen Prozeduren umzuschreiben.
1. Grundlegende Prozeduren für das gesamte Notebook
In diesem Notebook werden einige Prozeduren immer wieder verwendet.
Wir wollen sie deshalb gleich zu Beginn festlegen.
Die Prozedur roulette simuliert ein Roulettespiel, wobei n-Spiele gemacht werden
und der Spieler mit Wahrscheinlichkeit p gewinnt. Es wird eine Liste mit
Nullen und Einsen ausgegeben. Eine Eins gibt ein gewonnenes Spiel an,
die Null steht für ein verlorenes Spiel.
roulette:=proc(n,p)
local A,i,k;
begin
kessel:=stats::binomialRandom(1,p):kessel()$ k=1..n;
A:=[kessel() $i=1..n];
end_proc:
Nun werden wir eine Prozedur schreiben, die
a) den Spielverlauf angibt,
b) anzeigt, an welchen Stellen die Einsen stehen, zu welchen Zeitpunkten der Spieler also
gewonnen hat und
c) angibt, an welchen Stellen die Nullen stehen, wann der Spieler also verloren hat:
zeit:=proc(n,p)
local A,B,C,F,G,S,i,j;
begin
S:=roulette(n,p);
A:=[0$n];
A[1]:=contains(S,1);
for j from 2 to n do
A[j]:=contains(S,1,A[j-1]+1);
if A[j]=0 then break;
end_if;
end_for;
B:=[op(A,i)$i=1.._plus(op(S))];
C:=[0$n];
C[1]:=contains(S,0);
for j from 2 to n do
C[j]:=contains(S,0,C[j-1]+1);
if C[j]=0 then break;
end_if;
end_for;
F:=[op(C,i)$i=1..n-_plus(op(S))];
G:=[S,B,F]
end_proc:
zeit(10,18/37)
Nun haben wir wichtige Prozeduren festgelegt und werden einige Strategien simulieren.
2. Progressionsspiele
a) Einfache Martingalstrategie
Empirisch untersucht werden soll zunächst die bekannte Verdoppelungsstrategie
beim Roulette - auch Einfache Martingalstrategie genannt.
Die Strategie sieht folgendermaßen aus:
Der Spieler beginnt mit K Euro und setzt einen Euro auf die Einfachen Chancen
(Rot oder Schwarz, Gerade oder Ungerade, Manque (Zahlen 1-18) oder Passe (Zahlen 19-36)).
Für die Erfolgswahrscheinlichkeit eines Laufs wählen wir p<1/2,
wobei die Null bereits berücksichtigt ist, z.B. p=18/37 (die Null ist weder Gerade, noch Ungerade,
weder Rot noch Schwarz).
Wenn der Spieler gewinnt, legt er den gewonnen Euro zu seinem Kapital und spielt weiter.
Falls der Spieler verliert, setzt er den doppelten Betrag des vorhergehenden Einsatzes ein.
Damit hofft er, eine Verlustserie mit einem Gewinn auszugleichen und sogar noch
einen Euro zu gewinnen.
Ein möglicher Spielverlauf könnte also sein:
1. Spiel: 1 Euro gesetzt - verloren
2. Spiel: 2 Euro gesetzt - verloren
3. Spiel: 4 Euro gesetzt - verloren
4. Spiel: 8 Euro gesetzt - gewonnen.
Diese stufenweise Steigerung der Satzhöhe nennt man Progression. Da sich die Steigerung
immer auf das vorher verlorene Spiel bezieht, ist diese Art der Strategie eine Verlustprogression.
Die Steigerung endet mit einem gewonnen Spiel und beginnt dann wieder von vorne, d.h., dass
dann ein neuer Progressionslauf beginnt.
In unserem Beispiel hatte der Spieler vor dem 4. Spiel insgesamt 7 Euro verloren, nun gewinnt
er nach dem 4. Spiel auf einen Schlag 8 Euro und hat insgesamt einen Euro gewonnen.
Dies hört sich gut an, doch in der Strategie verbergen sich Gefahren.
Diese Gefahren sollen deutlich gemacht werden.
Zuerst die Prozedur:
martingal:=proc(n,p,K)
local D,E,G,H,S,ST,Z,g,t;
begin
Z:=zeit(n,p);
S:=op(Z,1);/*Hier stehen die Spielstände*/
D:=op(Z,2);/*Hier stehen die Gewinnzeiten*/
E:=op(Z,3);/*Hier stehen die Verlustzeiten*/
/*-----------------------------------------------------------*/
/*Im folgenden Abschnitt wird die Martingalstrategie simuliert*/
G:=[0$n];
if S[1]=1 then G[1]:=K+1;
else G[1]:=K-1;
end_if;
for t from 2 to nops(S) do
if S[t]=1 then G[t]:=K+contains(D,t);
elif S[t]=0 then
if S[t-1]=1 then G[t]:=G[t-1]-1;
elif S[t-1]=0 then
for g from 2 to t do
if has(E,t-g)=TRUE then G[t]:=G[t-1]-(2^(g));
elif has(E,t-g)=FALSE then
G[t]:=G[t-1]-(2^(g-1));break;
end_if;
end_for;
end_if;
end_if;
end_for;
ST:=[op(G,t)$t=1..nops(G)];
/*Hier stehen jetzt die Spielstände*/
end_proc:
Nun gibt man an, wie viele Spiele man spielen und mit welchem Anfangsbetrag man starten will
(als Erfolgswahrscheinlichkeit wähle man der Einfachheit halber beim Setzen auf die
Einfachen Chancen p=18/37).
Die folgende Liste gibt die Spielstände an:
martingal(10,18/37,100)
Die folgende Grafik verdeutlicht den Spielverlauf nach 100 Spielen mit einem Anfangsbetrag von
50 Euro anschaulich. Man gewinnt auf Dauer ungefähr in jedem zweiten Spiel einen Euro, aber
eine längere Verlustserie ruiniert den Spieler (abhängig vom Starteinsatz).
Dazu im Folgenden mehr.
kurve1:=martingal(100,18/37,50):
Punkte1:=[n,kurve1[n]]$n=1..100:
plot(plot::Polygon2d([Punkte1],
AxesTitles=["Spiel","Kontostand"]));
Wir sehen an dem obigen Beispiel, dass man nach 100 Spielen mit einem Anfangsbetrag von
50 Euro ungefähr 100 Euro in der Tasche hat. Problematisch ist dabei allerdings die Tatsache,
dass wir bei einer Verlustserie von 6 Spielen pleite sind und dann gar nicht mehr weiter spielen
könnten, denn wir hätten nach 6 Spielen 63 Euro verloren und müssten im
nächsten Spiel 64 Euro einsetzen, die wir aber gar nicht mehr in der Tasche haben.
Die Prozedur dauer gibt an, wann der Spieler das erste Mal bankrott ist:
dauer:=proc(n,p,K)
local N,P;
begin
N:=martingal(n,p,K):
P:=select(N,hastype,Type::NegInt):
contains(N,op(P,1))
end_proc:
dauer(100,18/37,50)
Der Spieler ist in diesem Beispiel schon nach 7 Spielen pleite, wenn er mit 50 Euro beginnt.
Wir wollen noch wissen, wie lang die längste Verlustserie ist:
verlustserie:=proc(n,p,K)
local D,E,G,H,J,L,S,ST,Z,g,t,q,s;
begin
Z:=zeit(n,p);
S:=op(Z,1);
D:=op(Z,2);
E:=op(Z,3);
G:=[0$n];
if S[1]=1 then G[1]:=K+1;
else G[1]:=K-1;
end_if;
for t from 2 to nops(S) do
if S[t]=1 then G[t]:=K+contains(D,t);
elif S[t]=0 then
if S[t-1]=1 then G[t]:=G[t-1]-1;
elif S[t-1]=0 then
for g from 2 to t do
if has(E,t-g)=TRUE then G[t]:=G[t-1]-(2^(g));
elif has(E,t-g)=FALSE then
G[t]:=G[t-1]-(2^(g-1));break;
end_if;
end_for;
end_if;
end_if;
end_for;
ST:=[op(G,t)$t=1..nops(G)];
/*-------------------------------------------------------------*/
/*Bis hier war die Prozedur wie gehabt, nun folgt die
Programmierung der Verlustserie*/
H:=[0$n];
for q from 2 to nops(D) do
H[q]:=((op(D,q)-op(D,q-1)-1));
end_for;
J:=([op(H,s)$s=1..n]);
L:=max(max(J),op(D,1)-1,n-op(D,nops(D)));
end_proc:
verlustserie(100,18/37,50)
In diesem Beispiel hat der Spieler also achtmal in Folge verloren! Er hat dabei 255 Euro
verloren und ist folglich pleite.
Nun ist es interessant zu betrachten, was geschieht, wenn das Tischminimum nicht 1 Euro,
sondern m Euro ist.
Schließlich existieren in Deutschland Tische mit 2,5,10, 20 und auch 50 Euro Tischminimum.
martingalminimum:=proc(n,p,K,m)
local D,E,G,S,ST,Z,g,t;
begin
Z:=zeit(n,p);
S:=op(Z,1);/*Hier stehen die Spielstände*/
D:=op(Z,2);/*Hier stehen die Gewinnzeiten*/
E:=op(Z,3);/*Hier stehen die Verlustzeiten*/
/*-----------------------------------------------------------*/
/*Im folgenden Abschnitt wird die Martingalstrategie simuliert*/
G:=[0$n];
if S[1]=1 then G[1]:=K+m;
else G[1]:=K-m;
end_if;
for t from 2 to nops(S) do
if S[t]=1 then G[t]:=K+contains(D,t)*m;
elif S[t]=0 then
if S[t-1]=1 then G[t]:=G[t-1]-m;
elif S[t-1]=0 then
for g from 2 to t do
if has(E,t-g)=TRUE then G[t]:=G[t-1]-(2^(g)*m);
elif has(E,t-g)=FALSE then
G[t]:=G[t-1]-(2^(g-1)*m);break;
end_if;
end_for;
end_if;
end_if;
end_for;
ST:=[op(G,t)$t=1..nops(G)]; /*Hier stehen jetzt die Spielstände*/
end_proc:
martingalminimum(10,18/37,50,2)
Auch diese Werte wollen wir einmal graphisch veranschaulichen. Je größer das Tischminimum,
desto größer werden natürlich auch die Ausschläge der Kurve, weil durch das Verdoppeln
die Einsätze schneller anwachsen.
kurve2:=martingalminimum(100,18/37,50,5):
Punkte2:=[n,kurve2[n]]$n=1..100:
plot(plot::Polygon2d([Punkte2],
AxesTitles=["Spiel","Kontostand"]));
Der Leser beachte die Ausschläge unter die x-Achse.
Das Spiel wäre natürlich bereits nach dem ersten Erreichen der x-Achse beendet, weil der
Spieler bankrott wäre.
b) Supermartingalstrategie
Die Supermartingalstrategie ist eine Abwandlung der Einfachen Martingalstrategie.
Das Progressionsschema der Supermartingale verläuft steiler als das der Einfachen Martingale:
1-3-7-15-31-63-127-255-511-1023.
Der vorhergehende Einsatz wird verdoppelt und eine Satzeinheit wird noch addiert. Ansonsten
gelten die gleichen Regeln wie bei der Einfachen Martingalstrategie
Wir wollen diese Strategie gleich mit einem beliebigen Tischminimum m simulieren:
supermartingal:=proc(n,p,K,m)
local D,E,G,S,ST,Z,g,t;
begin
Z:=zeit(n,p);
S:=op(Z,1);/*Hier stehen die Spielstände*/
D:=op(Z,2);/*Hier stehen die Gewinnzeiten*/
E:=op(Z,3);/*Hier stehen die Verlustzeiten*/
/*-----------------------------------------------------------*/
/*Im folgenden Abschnitt wird die Supermartingalstrategie simuliert*/
G:=[0$n];
if S[1]=1 then G[1]:=K+m;
else G[1]:=K-m;
end_if;
for t from 2 to nops(S) do
if S[t]=1 then G[t]:=K+t*m;
elif S[t]=0 then
if S[t-1]=1 then G[t]:=G[t-1]-m;
elif S[t-1]=0 then
for g from 2 to t do
if has(E,t-g)=TRUE then
G[t]:=G[t-1]-(2*(2^(g)*m)-m);
elif has(E,t-g)=FALSE then
G[t]:=G[t-1]-(2*(2^(g-1)*m)-m);break;
end_if;
end_for;
end_if;
end_if;
end_for;
ST:=[op(G,t)$t=1..nops(G)];
end_proc:
supermartingal(10,18/37,100,1)
kurve3:=supermartingal(100,18/37,50,5):
Punkte3:=[n,kurve3[n]]$n=1..100:
plot(plot::Polygon2d([Punkte3],
AxesTitles=["Spiel","Kontostand"]));
Wir sehen: Die Kurve verläuft wesentlich steiler als bei der Einfachen Martingalstrategie.
Der Spieler kann im Schnitt pro Spiel mit zwei gewonnen Satzeinheiten rechnen, durch die
hohen Einsätze allerdings auch mit einer höheren Wahrscheinlichkeit für größere Verluste,
die ihn schneller in den Bankrott bringen können.
Im 4. Notebook werden die Strategien untereinander bei gleichem Spielverlauf verglichen.
Wir werden dort sehen, wie sich der Kontostand des Spielers entwickelt hätte, wenn er bei
identischem Spielverlauf die Supermartingalstrategie oder die Einfache Martingalstrategie
gespielt hätte.
_______________________________________________________________________________
Anmerkungen:
1. Weitere Anregungen zum Einsatz von MuPAD in der Lehre finden Sie auf unserem WebPortal
MuPAD in Schule und Studium unter: http://schule.mupad.de bzw. http://studium.mupad.de.
2. Mathematische Formeln in diesem Notebook stammen aus der Examensarbeit
"Roulette - Theorie und Simulation eines Glücksspiels", die vom Autor im Rahmen
der Ersten Staatsprüfung für das Lehramt an Gymnasien im Jahr 2004 am
Institut für Mathematische Stochastik an der Georg-August Universität in
Göttingen angefertigt wurde. Die programmierten Roulettestrategien wurden im
Rahmen dieser Arbeit ebenfalls mathematisch untersucht.
Der interessierte Leser sei darauf verwiesen. Entsprechende Teile der Arbeit
können gerne auf Anfrage beim Autor angefordert werden.
_______________________________________________________________________________