_____________________________________________________________________________________
Inhalt....: Roulettestrategien III
Kategorie.: Arbeitsblatt
Mathematik: Stochastik, Programmierung
MuPAD.....: 3.1.0
Datum.....: 2005-07-04
Autoren...: Thorsten Fraas <thorstenfraas@gmx.de>
Funktionen: contains, for, has, if, stats::binomialRandom, begin
Funktionen: op, plot::Polygon2d, AxesTitles
_____________________________________________________________________________________
Empirische Untersuchung von Roulettestrategien III
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) Amerikanische Martingalstrategie
b) Whittacker Progression
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)
2. Progressionsspiele
Eine Einführung in die Theorie der Progessionsspiele findet sich in den ersten beiden
Notebooks ("roulette1.mnb" und "roulette2.mnb").
Wer mit den Begriffen und der Anwendung nicht vertraut ist, sollte dort nachlesen.
a) Amerikanische Martingalstrategie
Die Progression der amerikanischen Martingalstrategie verläuft folgendermaßen:
1-2-3-4-5-6-...
Der Spieler setzt also bei vorhergehendem verlorenen Spiel immer einen Euro mehr
als im Spiel zuvor.
Gewinnt er, so legt er das gewonnene Geld zu seinem Kapital und beginnt von vorne.
Wir wollen diese Strategie programmieren:
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:
amerimartingal(10,18/37,50,5)
Wir veranschaulichen 100 Spiele mit der Amerikanischen Martingalstrategie bei einem
Startkapital von 50 Euro und einem Einsatz von einem Euro.
kurve4:=amerimartingal(100,18/37,50,1):
Punkte4:=[n,kurve4[n]]$n=1..100:
plot(plot::Polygon2d([Punkte4],
AxesTitles=["Spiel","Kontostand"]));
Der Verlauf des Kontostandes beim Spielen dieser Strategie ist flacher als der der anderen
beiden Martingalstrategien, da die Einsätze weniger schnell ansteigen. Das hat den Vorteil,
dass die Einsätze nicht so schnell an das Tischmaximum heranreichen, allerdings bringt ein
Gewinn den Spieler nach mehreren verlorenen Spielen aufgrund der flachen Progression auch
nicht mehr zurück in die Gewinnzone.
b) Whittacker-Progression
Die Whittacker-Progression ist eine Verlustprogression mit folgendem Progressionsschema:
1-2-3-5-8-13-21-...
Die nächste Satzhöhe nach einem verlorenen Spiel ist also die Summe der vorangegangenen
beiden Satzhöhen. Ansonsten sind die Regeln die gleichen, wie bei den obigen Strategien.
Die Prozedur sieht folgendermaßen aus:
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:
whittacker(10,1/2,50,1)
Auch hier wollen wir den Verlauf des Kontostandes veranschaulichen:
kurve5:=whittacker(100,18/37,50,1):
Punkte5:=[n,kurve5[n]]$n=1..100:
plot(plot::Polygon2d([Punkte5],
AxesTitles=["Spiel","Kontostand"]));
Der Spieler kann mit dieser Strategie nur die Verluste der letzten beiden Spiele zurückgewinnen.
Ist seine Verlustserie länger, so kann er mit dieser Strategie keinen Gewinn erzielen.
Wo sich diese Strategie einordnen lässt, wird erst beim Vergleich mit den anderen deutlich.
Wir werden dies im 4. Notebook sehen.
_______________________________________________________________________________
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.
_______________________________________________________________________________