_____________________________________________________________________________________
Inhalt....: Roulettestrategien IV
Kategorie.: Arbeitsblatt
Mathematik: Stochastik, Programmierung
MuPAD.....: 3.1.0
Datum.....: 2005-07-04
Autoren...: Thorsten Fraas <thorstenfraas@gmx.de>
Funktionen: for, has, if, proc, begin, stats::binomialRandom
Funktionen: op, plot::Polygon2d, contains, Color, Legend
_____________________________________________________________________________________
Empirische Untersuchung von Roulettestrategien IV
Zur Einführung bitte die Einleitung in dem Notebook "roulette1.mnb" lesen.
Vergleich der Roulettestrategien
Wir wollen sehen, was mit dem Kontostand eines Spielers passieren würde, wenn bei
einem für alle Strategien gleichen Spielverlauf entweder die
a) Masse égale-Strategie,
b) die Einfache Martingalstrategie,
c) die Supermartingalstrategie
d) die amerikanische Martingalstrategie oder
e) die Whittacker Progression
gespielt werden würde. Wir vergleichen die Strategien also anhand eines identischen
Spielverlaufs.
In der folgenden Prozedur gibt n die Anzahl der Spiele an, K das Startkapital und m den
Einsatz, mit dem der Spieler einen Lauf beginnt (in der Regel das Tischminimum).
Die Prozedur besteht aus allen bisher programmierten Strategien.
komplett:=proc(n,p,K,m)
begin
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:
Liste:=roulette(n,p);
zeit:=proc(n,p)
local A,B,C,F,G,i,j;
begin
S:=Liste;
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:
spielstaendeallg:=proc(n,p,K,m)
local A,B,Z,i;
begin
Z:=zeit(n,p);
A:=op(Z,1);
B:=[];
if A[1]>0 then A[1]:=K+m;
else A[1]:=K-m;
end_if;
for i from 2 to nops(A) do
if A[i]=1 then A[i]:=A[i-1]+m;
elif A[i]=0 then A[i]:=A[i-1]-m;
end_if;
end_for;
B:=[op(A,i)$i=1..nops(A)];
end_proc:
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:
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:
amerimartingal:=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 Strategie 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
if contains(D,t)=1 then G[t]:=G[t-1]+t*m
else G[t]:=G[t-1]+(t-op(D,contains(D,t)-1))*m;
end_if;
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]-((g+1)*m);
elif has(E,t-g)=FALSE then G[t]:=G[t-1]-(g*m);break;
end_if;
end_for;
end_if;
end_if;
end_for;
ST:=[op(G,t)$t=1..nops(G)];
end_proc:
whittacker:=proc(n,p,K,m)
local D,E,G,S,ST,Z,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 Strategie 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
if contains(D,t)=1 and t=2 then G[t]:=K+m
elif contains(D,t)=1 and t=3 then G[t]:=K
elif contains(D,t)=1 and t>3 then G[t]:=G[t-3]
elif contains(D,t)>1 and (t-op(D,contains(D,t)-1))=1 then
G[t]:=G[t-1]+m
elif contains(D,t)>1 and (t-op(D,contains(D,t)-1))=2 then
G[t]:=G[t-2]+m
elif contains(D,t)>1 and (t-op(D,contains(D,t)-1))>2 then
G[t]:=G[t-3]
end_if;
elif S[t]=0 then
if contains(E,t)=1 then G[t]:=G[t-1]-m
elif contains(E,t)=2 and (t-op(E,contains(E,t)-1))=1 then
G[t]:=G[t-1]-2*m
elif contains(E,t)=2 and (t-op(E,contains(E,t)-1))>1 then
G[t]:=G[t-1]-m
elif contains(E,t)>2 and (t-op(E,contains(E,t)-1))>1 then
G[t]:=G[t-1]-m
elif contains(E,t)>2 and (t-op(E,contains(E,t)-1))=1
and (t-op(E,contains(E,t)-2))=2 and t=3 then
G[t]:=G[t-1]-3*m
elif contains(E,t)>2 and (t-op(E,contains(E,t)-1))=1
and (t-op(E,contains(E,t)-2))=2 and t<>3 then
G[t]:=G[t-1]-(G[t-3]-G[t-1])
elif contains(E,t)>2 and (t-op(E,contains(E,t)-1))=1
and (t-op(E,contains(E,t)-2))>2 then
G[t]:=G[t-1]-2*m
end_if;
end_if;
end_for;
ST:=[op(G,t)$t=1..nops(G)];
end_proc:
graph:=spielstaendeallg(n,p,K,m):
Punktliste:=[l,graph[l]]$l=1..n:
PU:=plot::Polygon2d([Punktliste],
AxesTitles=["Spiel","Kontostand"],
Color=RGB::Blue,
Legend = "Masse égale-Spiel"):
graph1:=martingalminimum(n,p,K,m):
Punktliste1:=[l,graph1[l]]$l=1..n:
PU1:=plot::Polygon2d([Punktliste1],
AxesTitles=["Spiel","Kontostand"],
Color=RGB::Black,
Legend = "Einfache Martingalstrategie"):
graph2:=supermartingal(n,p,K,m):
Punktliste2:=[l,graph2[l]]$l=1..n:
PU2:=plot::Polygon2d([Punktliste2],
AxesTitles=["Spiel","Kontostand"],
Color=RGB::Red,
Legend = "Supermartingalstrategie"):
graph3:=amerimartingal(n,p,K,m):
Punktliste3:=[l,graph3[l]]$l=1..n:
PU3:=plot::Polygon2d([Punktliste3],
AxesTitles=["Spiel","Kontostand"],
Color=RGB::PermanentGreen,
Legend = "Amerikanische Martingalstrategie"):
graph4:=whittacker(n,p,K,m):
Punktliste4:=[l,graph4[l]]$l=1..n:
PU4:=plot::Polygon2d([Punktliste4],
AxesTitles=["Spiel","Kontostand"],
Color=RGB::LightOrange,
Legend = "Whittacker Progression");
PU5:=plot::Line2d([0, K], [n,K],LineStyle=Dashed,
Color=RGB::Black):
plot(PU,PU1,PU2,PU3,PU4,PU5,
Width = 16*unit::cm,
Height = 12*unit::cm)
end_proc:
Im Folgenden machen wir 200 Spiele bei einem Startkapital von 100 Euro und einem
Einsatz von 10 Euro.
Das Schaubild zeigt uns den Verlauf des Kontostandes beim Spielen der 5 Strategien:
komplett(200,1/2,100,10)
Nun können wir die Strategien untereinander vergleichen. Es fällt auf, dass der Kontostand beim
Spielen der Supermartingalstrategie am Ende am höchsten ist. Das ist kein Wunder, denn diese
Strategie hat das steilste Progressionsschema. Man gewinnt im Schnitt pro Spiel zwei
Satzeinheiten. Doch auch die Gefahr dieser Strategie wird im Schaubild deutlich:
Durch die hohen Einsätze ist die Gefahr eines Bankrotts hier am größten. Eine Verlustserie kann
den Spieler (abhängig vom Startkapital und dem Tischminimum) schnell in den Ruin treiben.
Außerdem kann bei dieser Strategie schnell das Tischmaximum erreicht werden.
Gewöhnlich liegt es bei 2 und 5 Euro Tischen für die Einfachen Chancen bei 7000 Euro.
Bei der Einfachen Martingalstrategie liegen dieselben Risiken vor, der Spieler kann sich aber
eine etwas längere Verlustserie leisten, da die Einsätze nicht ganz so schnell steigen. Wir haben
aber gesehen, dass auch diese Strategie auf lange Sicht zu gefährlich ist, da sich die
Wahrscheinlichkeit, bankrott zu gehen, im Schnitt mit der Anzahl der getätigten Spiele erhöht.
Auf sehr kurze Sicht könnte man mit der Strategie etwas Geld verdienen, doch Strategien sind
dazu da, lange gespielt zu werden und dies funktioniert hier nicht. Der Leser kann sich davon
überzeugen, indem er die Anzahl n der Spiele in den Prozeduren erhöht. Man wird fast sicher bei
großem n in einem der n Spiele bankrott gehen. Theoretisch lässt sich dies natürlich auch zeigen.
Es sei hier auf die in der Anmerkung erwähnte Examensarbeit verwiesen.
Alle übrigen Progressionen laufen in Abstufungen nach flacheren Progressionsschemata ab,
also ist die Gefahr eines Bankrotts geringer, man erzielt im Schnitt aber auch einen geringeren
Gewinn; mit obigem Spielverlauf hätte man beim Spielen der Masse égale-Strategie sogar nach
200 Spielen einen Verlust zu beklagen und mit der amerikanischen Martingalstrategie würde man
lediglich wieder bei seinem Startkapital landen. Auch diese Strategien sind mit den gleichen
abgeschwächten Argumenten wie oben nicht empfehlenswert. Man mache sich das durch
Wiederholen der Prozeduren an den entsprechenden Graphen einmal deutlich.
Doch lohnt sich wenigstens das Masse égale-Spiel? Klares Nein! Sie ist die denkbar schlechteste
Strategie: Wir hatten gesehen, dass es z.B. klüger ist, im ersten Spiel "Alles oder Nichts"
zu spielen, da dort nur eine Bankrottwahrscheinlichkeit von etwas mehr als 50% vorliegt und man
z.B. sein Startkapital von 50 Euro verdoppeln kann. Wollte man das mit dem Masse égale-Spiel
erreichen, würde man mit einer Wahrscheinlichkeit von über 93% scheitern!!
Fazit: Albert Einstein soll einmal gesagt haben "Auf keinen Fall bringt es einer fertig, beim Roulette
zu gewinnen, es sei denn, er stiehlt Geld vom Tisch, wenn der Croupier nicht hinsieht."
Dem ist nichts hinzuzufügen.
_______________________________________________________________________________
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.
_______________________________________________________________________________