Erwartungswert Münzwürfe bis Ruin

07.08.2020, 14:26

Dopap

Erwartungswert Münzwürfe bis Ruin

ohne viel Geschichten:

1. ein linearer random walk mit p=1/2. Was ist der Erwartungswert an Schritten bis der Abstand n erreicht ist?
----
Sieht simuliert nach $\begin{eqnarray*} \approx n^2 \end{eqnarray*}$ aus.

07.08.2020, 19:45

Finn_

Auf diesen Beitrag antworten »

Sei $\begin{eqnarray*} (X_n) \end{eqnarray*}$ der Random Walk mit
$\begin{eqnarray*} X_n := a+\sum_{k=1}^n Z_k, \end{eqnarray*}$
wobei $\begin{eqnarray*} Z_k\colon\Omega\to\{-1,1\} \end{eqnarray*}$ gleichverteilt ist.

Man definiert die Wartezeit für erstmaliges Erreichen von Zustand $\begin{eqnarray*} b \end{eqnarray*}$ aus Zustand $\begin{eqnarray*} a \end{eqnarray*}$ als
$\begin{eqnarray*} \tau_{a,b} := \min\{n\ge 1\mid X_0 = a\land X_n = b\}. \end{eqnarray*}$

Nun ist $\begin{eqnarray*} \tau_{a,b} \end{eqnarray*}$ eine neue Zufallsgröße mit Zielmenge $\begin{eqnarray*} \mathbb N_{\ge 1} \end{eqnarray*}$ . Gesucht ist der Erwartungswert $\begin{eqnarray*} E(\tau_{0,b}) \end{eqnarray*}$ bzw. $\begin{eqnarray*} E(\tau_{0,n}) \end{eqnarray*}$ . Mit
$\begin{eqnarray*} E(\tau_{a,b}) = \sum_{k=1}^\infty kP(\tau_{a,b}=k) \end{eqnarray*}$
reduziert sich das Problem auf die Bestimmung von $\begin{eqnarray*} P(\tau_{a,b}=k) \end{eqnarray*}$ .

Die Anzahl aller möglichen Pfade mit Anfang $\begin{eqnarray*} a \end{eqnarray*}$ und $\begin{eqnarray*} k \end{eqnarray*}$ Schritten ist $\begin{eqnarray*} 2^k \end{eqnarray*}$ , also endlich, womit lediglich ein kombinatorisches Problem verbleibt. Wir müssen schlicht die Pfade von $\begin{eqnarray*} k \end{eqnarray*}$ Schritten mit $\begin{eqnarray*} \tau_{a,b} = k \end{eqnarray*}$ zählen.

Es bietet sich mal wieder das Zusammenfrickeln eines Python-Programms zur Berechnung der Anzahl an. Geht für kleine Werte von $\begin{eqnarray*} k \end{eqnarray*}$ bis ca. 26. Die Wertetabelle hilft eventuell bei der Auffindung einer Formel.

07.08.2020, 21:06

Huggy

Auf diesen Beitrag antworten »

RE: Erwartungswert Münzwürfe bis Ruin
Es sei $\begin{eqnarray*} Z(n,i) \end{eqnarray*}$ der Erwartungswert der Zahl der Schritte, die es braucht, um aus dem Zustand $\begin{eqnarray*} i \end{eqnarray*}$ mit $\begin{eqnarray*} -n \le i \le n \end{eqnarray*}$ in einen der beiden absorbierenden Zustände $\begin{eqnarray*} i=\pm n \end{eqnarray*}$ zu kommen. Wegen der Symmetrie des Problems kann man annehmen, dass man im ersten Schritt aus dem Zustand $\begin{eqnarray*} i=0 \end{eqnarray*}$ in den Zustand i $\begin{eqnarray*} =1 \end{eqnarray*}$ kommt. Dadurch genügt es, die Zustände mit $\begin{eqnarray*} i \ge 0 \end{eqnarray*}$ zu betrachten. Es ergibt sich das Gleichungssystem

$\begin{eqnarray*} Z(n,0)=1+Z(n,1) \end{eqnarray*}$

$\begin{eqnarray*} Z(n,i)=1+\frac 1 2 (Z(n,i-1)+Z(n,i+1)) \text { für } 1 \le i \le n-1 \end{eqnarray*}$

$\begin{eqnarray*} Z(n,n)=0 \end{eqnarray*}$

Das Gleichungssystem hat die Lösung

$\begin{eqnarray*} Z(n,i)=n^2-i^2 \end{eqnarray*}$

Das kann man durch Einsetzen der Lösung in das System leicht verifizieren. Es ist also insbesondere

$\begin{eqnarray*} Z(n,0)=n^2 \end{eqnarray*}$

08.08.2020, 09:18

Finn_

Auf diesen Beitrag antworten »

Einseitig scheint die Reihe irgendwie divergent zu sein. Betrachten wir für $\begin{eqnarray*} X_0:=0 \end{eqnarray*}$ stattdessen die Wartezeit bezüglich Abstand:

$\begin{eqnarray*} \tau_n := \min\{i\ge 1\mid |X_i| = n\}. \end{eqnarray*}$

Es folgt die Tabelle $\begin{eqnarray*} 2^k P(\tau_n=k) \end{eqnarray*}$ .

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

     |  k=1  k=2  k=3  k=4  k=5  k=6  k=7  k=8  k=9 k=10 k=11 k=12 k=13 k=14 k=15
---------------------------------------------------------------------------------
n= 0 |    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0
n= 1 |    2    0    0    0    0    0    0    0    0    0    0    0    0    0    0
n= 2 |    0    2    0    4    0    8    0   16    0   32    0   64    0  128    0
n= 3 |    0    0    2    0    6    0   18    0   54    0  162    0  486    0 1458
n= 4 |    0    0    0    2    0    8    0   28    0   96    0  328    0 1120    0
n= 5 |    0    0    0    0    2    0   10    0   40    0  150    0  550    0 2000
n= 6 |    0    0    0    0    0    2    0   12    0   54    0  220    0  858    0
n= 7 |    0    0    0    0    0    0    2    0   14    0   70    0  308    0 1274
n= 8 |    0    0    0    0    0    0    0    2    0   16    0   88    0  416    0
n= 9 |    0    0    0    0    0    0    0    0    2    0   18    0  108    0  546
n=10 |    0    0    0    0    0    0    0    0    0    2    0   20    0  130    0
n=11 |    0    0    0    0    0    0    0    0    0    0    2    0   22    0  154
n=12 |    0    0    0    0    0    0    0    0    0    0    0    2    0   24    0
n=13 |    0    0    0    0    0    0    0    0    0    0    0    0    2    0   26
n=14 |    0    0    0    0    0    0    0    0    0    0    0    0    0    2    0
n=15 |    0    0    0    0    0    0    0    0    0    0    0    0    0    0    2

Das macht

$\begin{eqnarray*} E(\tau_1) = \sum_{k=1}^\infty kP(\tau_1=k) = \frac{1\cdot 2}{2^1} = 1, \end{eqnarray*}$

$\begin{eqnarray*} E(\tau_2) = \sum_{\substack{k=2\\ 2|k}}^\infty k\frac{2^{k/2}}{2^k} = 2\sum_{i=1}^\infty i\big(\tfrac{1}{2}\big)^i = 4, \end{eqnarray*}$

$\begin{eqnarray*} E(\tau_3) = \sum_{i=1}^\infty (2i+1)\frac{2\cdot 3^{i-1}}{2^{2i+1}} = 9. \end{eqnarray*}$

Sieht ganz nach $\begin{eqnarray*} E(\tau_n) = n^2 \end{eqnarray*}$ aus. Stellt sich die Frage nach einer geschlossenen Formel für die Tabelle.

08.08.2020, 09:25

Huggy

Auf diesen Beitrag antworten »

Zitat:

Original von Finn_
Sieht ganz nach $\begin{eqnarray*} E(\tau_n) = n^2 \end{eqnarray*}$ aus.

Was oben auf einfacherem Weg schon bewiesen wurde.

08.08.2020, 12:57

Dopap

Auf diesen Beitrag antworten »

also doch.
Den Binomialweg für allgemeines n war keine Option.
Der Gedanke, rekursiv über Erwartungswerte zu gehen war mir schon bekannt.
Hierzu gibt es ja zahlreiche Beispiele.
Nur war und ist mir die rechnerische Durchführung nicht klar, aber ein schönes Ergebnis.

09.08.2020, 08:39

Finn_

Auf diesen Beitrag antworten »

An der Tabelle ist ersichtlich, dass manchmal

$\begin{eqnarray*} 2^k P(\tau_n=k) + 2^kP(\tau_{n+2}=k) = 2^{k+1}P(\tau_{n+1}=k+1) \end{eqnarray*}$

gilt, vermutlich für $\begin{eqnarray*} k<3n \end{eqnarray*}$ .

09.08.2020, 16:24

Finn_

Auf diesen Beitrag antworten »

Transformieren wir das Koordinatensystem so, dass es um 45° gedreht ist und die erlaubten Gitterpunkte in $\begin{eqnarray*} \mathbb N_0^2 \end{eqnarray*}$ liegen.

[attach]51792[/attach]

Betrachten wir nun ein allgemeineres Problem. Ausgehend vom Punkt $\begin{eqnarray*} (0,0) \end{eqnarray*}$ ist die Anzahl der Pfade nach $\begin{eqnarray*} (x,y) \end{eqnarray*}$ gesucht, wobei man sich nur auf dem Gitter $\begin{eqnarray*} \mathbb N_0^2\setminus M \end{eqnarray*}$ nach rechts oder nach oben bewegen darf. Die Menge $\begin{eqnarray*} M\subseteq\mathbb N_0^2 \end{eqnarray*}$ ist beliebig.

Diese Anzahl nennen wir die Pfadzahl $\begin{eqnarray*} [M](x,y) \end{eqnarray*}$ . Klar ist bspw.

$\begin{eqnarray*} [\emptyset](x,y) = \binom{x+y}{x} = \binom{x+y}{y} = \frac{(x+y)!}{x! y!}. \end{eqnarray*}$

Die Zahl der Schritte ist ja bei jedem Pfad konstant, und zwar $\begin{eqnarray*} x \end{eqnarray*}$ Schritte nach rechts und $\begin{eqnarray*} y \end{eqnarray*}$ Schritte nach oben. Das macht insgesamt $\begin{eqnarray*} x+y \end{eqnarray*}$ Schritte. Von dieser Schrittfolge $\begin{eqnarray*} (0,1,\ldots,x+y-1) \end{eqnarray*}$ wählt man $\begin{eqnarray*} x \end{eqnarray*}$ aus, wo ein Schritt nach rechts kommen soll. Die Reihenfolge ist dabei unbedeutsam, also kommt die Anzahl der Kombinationen ohne Wiederholung bei raus.

Hier ist ein zweites Verfahren zur Berechnung aufgezeigt:
Carly Rozins: The grid path problem.

Demnach gilt die Rekursionsgleichung

$\begin{eqnarray*} [M](x,y) = [(x,y)\notin M]\cdot([M](x-1,y)+[M](x,y-1)). \end{eqnarray*}$

Wenn alles klappt, wird das den Rechenaufwand enorm reduzieren.

10.08.2020, 12:48

Finn_

Auf diesen Beitrag antworten »

Die Koordinatentransformation ist

$\begin{eqnarray*} \begin{pmatrix}x \\ y\end{pmatrix} = \frac{1}{2}\begin{pmatrix} 1 & -1\\ 1 & 1 \end{pmatrix}\begin{pmatrix}k \\ n\end{pmatrix} = \begin{pmatrix}(k-n)/2 \\ (k+n)/2\end{pmatrix}, \end{eqnarray*}$

Zur Angabe von $\begin{eqnarray*} M \end{eqnarray*}$ benötigen wir außerdem die Umkehrtransformation

$\begin{eqnarray*} \begin{pmatrix}k \\ n\end{pmatrix} = \begin{pmatrix} 1 & 1\\ -1 & 1 \end{pmatrix}\begin{pmatrix}x \\ y\end{pmatrix} = \begin{pmatrix}x+y \\ y-x\end{pmatrix}. \end{eqnarray*}$

Die bisherigen Überlegungen bringen die folgende rekursive Berechnung hervor.

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:

# Fixpunkt-Kombinator mit Memoisierung,
# für eine Funktion von zwei Argumenten.
def fix2(F):
    memo = {}
    def f(x,y):
        if (x,y) not in memo:
            memo[(x,y)] = F(f,x,y)
        return memo[(x,y)]
    return f

# Allgemeine Pfadzahl-Funktion [M](x,y).
def path_count(M):
    def F(f,x,y):
        if x<0 or y<0 or M(x,y): return 0
        return 1 if x==0 or y==0 else f(x-1,y) + f(x,y-1)
    return fix2(F)

# Spezielle Pfadzahl-Funktion zur vorgelegten Aufgabe.
def count(n,k):
    if (k-n)%2==1 or (k+n)%2==1: return 0
    def M(x,y):
        return x+y<k and abs(y-x)>=n
    return 2*path_count(M)((k-n)//2, (k+n)//2)

# Partialsumme des Erwartungswertes.
def E(n,kmax):
    return sum(k*count(n,k)/2**k for k in range(0,kmax+1))

def print_table(f,rn,rk):
    s = "".join(["{:>5}".format("k="+str(k)) for k in rk])
    print("     | {}".format(s))
    print("-"*(7+5*len(rk)))
    for n in rn:
        a = [f(n,k) for k in rk]
        s = "".join(["{:5}".format(z) for z in a])
        print("n={:2} | {}".format(n,s))

import sys
sys.setrecursionlimit(10**4)

print("Tabelle zu 2^k*P(tau[n] = k)")
print_table(count,range(0,16),range(0,16))

print("\nErwartungswert")
print(" n    E(tau[n])")
print("----------------")
for n in range(0,10):
    print("{:2}  {:12.8f}".format(n,E(n,600)))

13.08.2020, 17:16

Finn_

Auf diesen Beitrag antworten »

Kleine Korrektur: Die Zeile

code:
1:	return 1 if x==0 or y==0 else f(x-1,y) + f(x,y-1)

ist zu ersetzen gegen

code:
1:	return 1 if x==0 and y==0 else f(x-1,y) + f(x,y-1)

Der Fehler ist zwar bei count nicht aufgetreten, würde aber auftreten wenn $\begin{eqnarray*} M \end{eqnarray*}$ Punkte der Form $\begin{eqnarray*} (x,0) \end{eqnarray*}$ oder $\begin{eqnarray*} (0,y) \end{eqnarray*}$ enthält und die Berechnung per Rekursion auf Punkte dahinter -- d.h. $\begin{eqnarray*} (x+1,0), (x+2,0),\ldots \end{eqnarray*}$ -- zurückgeführt wird.

13.08.2020, 17:52

Finn_

Auf diesen Beitrag antworten »

Für die Pfadzahl will ich ab nun kurz $\begin{eqnarray*} M(p) \end{eqnarray*}$ schreiben, mit Punkt $\begin{eqnarray*} p=(x,y) \end{eqnarray*}$ und Menge $\begin{eqnarray*} M \end{eqnarray*}$ . Komische Notation, aber pragmatisch.

Wie gesagt gilt $\begin{eqnarray*} \emptyset(p) = \binom{x+y}{x} \end{eqnarray*}$ .

Ist da nun ein Punkt $\begin{eqnarray*} a=(a_x,a_y) \end{eqnarray*}$ Blockade, dann kann man zunächst alle Pfade von (0,0) bis $\begin{eqnarray*} p \end{eqnarray*}$ zählen und davon die Anzahl der Pfade durch $\begin{eqnarray*} a \end{eqnarray*}$ abziehen. Die Anzahl der Pfade durch $\begin{eqnarray*} a \end{eqnarray*}$ ergibt sich als das Produkt der Anzahl der Pfade von (0,0) bis $\begin{eqnarray*} a \end{eqnarray*}$ und der Anzahl der Pfade von $\begin{eqnarray*} a \end{eqnarray*}$ bis $\begin{eqnarray*} p \end{eqnarray*}$ . Das macht

$\begin{eqnarray*} \{a\}(p) = \emptyset(p) - \emptyset(a)\cdot\emptyset(p-a). \end{eqnarray*}$

Gibt es nun noch einen weiteren Punkt, der nicht strikt vor $\begin{eqnarray*} a \end{eqnarray*}$ steht, überlegt man sich entsprechend: Anzahl von (0,0) bis $\begin{eqnarray*} p \end{eqnarray*}$ minus Anzahl $\begin{eqnarray*} (0,0) \end{eqnarray*}$ bis $\begin{eqnarray*} a \end{eqnarray*}$ minus Anzahl von $\begin{eqnarray*} (0,0) \end{eqnarray*}$ bis $\begin{eqnarray*} b \end{eqnarray*}$ . Nun wurde die Zahl der Pfade durch $\begin{eqnarray*} a \end{eqnarray*}$ und $\begin{eqnarray*} b \end{eqnarray*}$ doppelt abgezogen, muss also einmal wieder hinzuaddiert werden. Das macht

$\begin{eqnarray*} \{a,b\}(p) = \emptyset(p) - \emptyset(a)\emptyset(p-a)-\emptyset(b)\emptyset(p-b) + \emptyset(a)\emptyset(b-a)\emptyset(p-b). \end{eqnarray*}$

Sei nun allgemein $\begin{eqnarray*} a \end{eqnarray*}$ ein Punkt und $\begin{eqnarray*} M \end{eqnarray*}$ eine Menge von übrigen Punkten. Keiner der Punkte in $\begin{eqnarray*} M \end{eqnarray*}$ stehe strikt vor $\begin{eqnarray*} a \end{eqnarray*}$ . Dafür überlegt man sich:

$\begin{eqnarray*} (\{a\}\cup M)(p) = M(p) - \emptyset(a)\cdot (M-a)(p-a). \end{eqnarray*}$

Mit $\begin{eqnarray*} M-a \end{eqnarray*}$ ist dabei die Menge $\begin{eqnarray*} \{u-a\mid u\in M\} \end{eqnarray*}$ gemeint.

Weil die Mengen angeordnet sind, müssen sie im Programm als Listen dargestellt werden. Demzufolge ergibt sich das folgende Programm.

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:

# Binomialkoeffizient
def bc(n,k):
    if k<0 or k>n:
        return 0
    elif k==0 or k==n:
        return 1
    else:
        y = 1; k = min(k,n-k)
        for i in range(0,k):
            y = y*(n-i)//(i+1)
        return y

# Vektorsubtraktion
def sub(a,b):
    return (a[0]-b[0], a[1]-b[1])

# Pfadzahl {}(p)
def paths0(p):
    return bc(p[0]+p[1],p[0])

# Pfadzahl M(p)
def paths(M,p):
    if len(M)==0:
        return paths0(p)
    else:
        a = M[0]; subM1a = [sub(u,a) for u in M[1:]]
        return paths(M[1:],p) - paths0(a)*paths(subM1a,sub(p,a))

Bei der Aufgabe kommt nun die Schwierigkeit hinzu, wie die Punkte der Blockadelinien anzuordnen sind. Bei einer Blockadelinie ist es klar, allerdings gibt es ja noch die zweite unten. Hier kann man im Zickzack gehen, damit jeweils der Rest nicht strikt vor dem Punkt steht.

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

def block_list(n,k):
    M = []
    for i in range(n,k,2):
        M.append((i,n))
        M.append((i,-n))
    return [((k-n)//2, (k+n)//2) for (k,n) in M]

def count(n,k):
    if (k-n)%2==1 or (k+n)%2==1: return 0
    M = block_list(n,k)
    return 2*paths(M,((k-n)//2, (k+n)//2))

13.08.2020, 18:21

Finn_

Auf diesen Beitrag antworten »

Mit strikt vor ist die folgende Relation gemeint: Der Punkt $\begin{eqnarray*} a \end{eqnarray*}$ liege strikt vor $\begin{eqnarray*} b \end{eqnarray*}$ , wenn es einen Pfad gibt, der zuerst durch $\begin{eqnarray*} a \end{eqnarray*}$ und dann durch $\begin{eqnarray*} b \end{eqnarray*}$ geht.

Ist weder $\begin{eqnarray*} a \end{eqnarray*}$ strikt vor $\begin{eqnarray*} b \end{eqnarray*}$ noch $\begin{eqnarray*} b \end{eqnarray*}$ strikt vor $\begin{eqnarray*} a \end{eqnarray*}$ , nennen wir $\begin{eqnarray*} a \end{eqnarray*}$ und $\begin{eqnarray*} b \end{eqnarray*}$ nicht gemeinsam besuchbar.

13.08.2020, 19:25

Finn_

Auf diesen Beitrag antworten »

Die Komplexität von paths ist vermutlich exponentiell, wogegen auch wieder fix2 anwendbar ist. Allerdings müssen dafür die Listen gegen Tupel ersetzt werden, weil Listen in Python nicht hashbar sind.

Das Programm stellt sich damit nun in der folgenden Modifikation dar:

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

def new_paths():
    def F(f,M,p):
        if len(M)==0:
            return paths0(p)
        else:
            a = M[0]; subM1a = tuple(sub(u,a) for u in M[1:])
            return f(M[1:],p) - paths0(a)*f(subM1a,sub(p,a))
    return fix2(F)

paths = new_paths()

def block_list(n,k):
    M = []
    for i in range(n,k,2):
        M.append((i,n))
        M.append((i,-n))
    return tuple(((k-n)//2, (k+n)//2) for (k,n) in M)

14.08.2020, 09:51

Finn_

Auf diesen Beitrag antworten »

Für die Pfadzahl findet sich die Formel

$\begin{eqnarray*} \{a_1,\ldots,a_n\}(p) = \sum_{k=0}^n (-1)^k \sum_{I\in B(n,k)} \prod_{(i,j)\in I} \emptyset(a_j-a_i), \end{eqnarray*}$

wobei $\begin{eqnarray*} a_0:=(0,0) \end{eqnarray*}$ und $\begin{eqnarray*} a_{n+1}:=p \end{eqnarray*}$ .

Hierbei ist $\begin{eqnarray*} B(n,k) \end{eqnarray*}$ die Menge der Indexpaarmengen für $\begin{eqnarray*} k \end{eqnarray*}$ Besuche in den $\begin{eqnarray*} n \end{eqnarray*}$ Punkten. Haben wir bspw. $\begin{eqnarray*} 3 \end{eqnarray*}$ Punkte $\begin{eqnarray*} a_1,a_2,a_3 \end{eqnarray*}$ , dann ist:

B(3,0) = {{(0,4)}}

B(3,1) = {{(0,1), (1,4)}, {(0,2), (2,4)}, {(0,3), (3,4)}}

B(3,2) = {
{(0,1), (1,2), (2,4)},
{(0,1), (1,3), (3,4)},
{(0,2), (2,3), (3,4)},
}

B(3,3) = {{(0,1), (1,2), (2,3), (3,4)}}

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:

from itertools import combinations

def prod(iterable):
    p = 1
    for n in iterable:
        p *= n
    return p

def pairs(t,n):
    if len(t)==0: return [(0,n+1)]
    I = [(0,t[0])]
    for i in range(1,len(t)):
        I.append((t[i-1],t[i]))
    I.append((t[len(t)-1],n+1))
    return I

# Liste von Indexpaarlisten für k Besuche von n Punkten
def B(n,k):
    return [pairs(t,n) for t in combinations(range(1,n+1),k)]

# Pfadzahl M(p)
def paths(M,p):
    n = len(M); a = [(0,0)] + M + [p]
    return sum((-1)**k*sum(prod(paths0(sub(a[j],a[i]))
        for (i,j) in I) for I in B(n,k)) for k in range(0,n+1))

14.08.2020, 10:16

Leopold

Auf diesen Beitrag antworten »

mathematischer Autismus

Neue Frage »

Antworten »

Erwartungswert Münzwürfe bis Ruin

Verwandte Themen