J'ai pensé à ce problème sous la douche, il a été inspiré par les stratégies d'investissement.

Disons qu'il y avait un arbre d'argent magique. Chaque jour, vous pouvez offrir une somme d'argent à l'arbre monétaire et il la triplera ou la détruira avec une probabilité de 50/50. Vous remarquez immédiatement qu'en moyenne, vous gagnerez de l'argent en faisant cela et vous avez hâte de profiter de l'arbre de l'argent. Cependant, si vous offriez tout votre argent en même temps, vous perdriez 50% de tout votre argent. Inacceptable! Vous êtes une personne peu averse au risque, vous décidez donc de trouver une stratégie. Vous voulez minimiser les chances de tout perdre, mais vous voulez aussi gagner autant d'argent que possible! Vous venez avec ce qui suit: chaque jour, vous offrez 20% de votre capital actuel à l'arbre monétaire. En supposant que le plus bas que vous puissiez offrir est de 1 cent, il vous faudrait 31 périodes de pertes pour perdre tout votre argent si vous commenciez avec 10 dollars. Quoi de plus, plus vous gagnez d'argent, plus la séquence de défaites doit être longue pour que vous perdiez tout, incroyable! Vous commencez rapidement à gagner beaucoup d'argent. Mais une idée vous vient à l'esprit: vous pouvez simplement offrir 30% par jour et gagner beaucoup plus d'argent! Mais attendez, pourquoi ne pas offrir 35%? 50%? Un jour, avec de gros signes en dollars dans les yeux, vous courez vers l'arbre à argent avec tous vos millions et offrez 100% de votre argent, que l'arbre à argent brûle rapidement. Le lendemain, vous obtenez un emploi chez McDonalds. que l'arbre d'argent brûle rapidement. Le lendemain, vous obtenez un emploi chez McDonalds. que l'arbre d'argent brûle rapidement. Le lendemain, vous obtenez un emploi chez McDonalds.

Y a-t-il un pourcentage optimal de votre argent que vous pouvez offrir sans tout perdre?

(sous) questions:

S'il y a un pourcentage optimal que vous devez proposer, est-ce statique (c'est-à-dire 20% par jour) ou le pourcentage devrait-il augmenter à mesure que votre capital augmente?

En offrant 20% chaque jour, les chances de perdre tout votre argent diminuent-elles ou augmentent-elles avec le temps? Y a-t-il un pourcentage d'argent d'où les chances de perdre tout votre argent augmentent avec le temps?

Il s'agit d'un problème bien connu. Cela s'appelle un pari Kelly. Soit dit en passant, la réponse est 1/3. Cela équivaut à maximiser l'utilité du journal de la richesse.

Kelly a commencé par prendre le temps de l'infini, puis à résoudre à l'envers. Comme vous pouvez toujours exprimer des retours en termes de composition continue, vous pouvez également inverser le processus et l'exprimer dans des journaux. Je vais utiliser l'explication de l'utilitaire de journal, mais l'utilitaire de journal est pratique. Si vous maximisez la richesse en vous vous retrouverez avec une fonction qui sera la même que l'utilitaire de journalisation. Si est la cote de paiement, et est la probabilité de gagner et est le pourcentage de richesse investie, alors la dérivation suivante fonctionnera.$n\to\infty$$b$$p$$X$

Pour un pari binaire, , pour une seule période et richesse unitaire.$E(\log(X))=p\log(1+bX)+(1-p)\log(1-X)$

$$\frac{d}{dX}{E[\log(x)]}=\frac{d}{dX}[p\log(1+bX)+(1-p)\log(1-X)]$$ $$=\frac{pb}{1+bX}-\frac{1-p}{1-X}$$

Mettre le dérivé à zéro pour trouver les extrema,

$$\frac{pb}{1+bX}-\frac{1-p}{1-X}=0$$

En multipliant, vous vous retrouvez avec

$$pb(1-X)-(1-p)(1+bX)=0$$ $$pb-pbX-1-bX+p+pbX=0$$ $$bX=pb-1+p$$ $$X=\frac{bp-(1-p)}{b}$$

Dans votre cas,

$$X=\frac{3\times\frac{1}{2}-(1-\frac{1}{2})}{3}=\frac{1}{3}.$$

Vous pouvez facilement étendre cela à des résultats multiples ou continus en résolvant l'utilité attendue de la richesse sur une distribution de probabilité conjointe, en choisissant les allocations et sous réserve de toute contrainte. Fait intéressant, si vous l'exécutez de cette manière, en incluant des contraintes, telles que la capacité de faire face aux paiements hypothécaires et ainsi de suite, alors vous avez comptabilisé votre ensemble total de risques et vous avez donc un risque ajusté ou au moins contrôlé par le risque Solution.

Desiderata Le but réel de la recherche originale avait à voir avec combien de jeu basé sur un signal bruyant. Dans le cas précis, combien jouer sur un signal électronique bruyant où il indiquait le lancement d'armes nucléaires par l'Union soviétique. Il y a eu plusieurs lancements à la fois par les États-Unis et la Russie, manifestement par erreur. Combien jouez-vous sur un signal?

J'ai aimé la réponse donnée par Dave Harris. tout en abordant le problème d'un point de vue "à faible risque", plutôt que de maximiser les profits

La marche aléatoire que vous faites, en supposant que votre mise de fraction est $q$ et que la probabilité de gagner $p=0.5$ est donnée par

$$Y_t|Y_{t-1}=(1-q+3qX_t)Y_{t-1}$$ où $X_t\sim Bernoulli(p)$ . vous avez en moyenne $$E(Y_t|Y_{t-1}) = (1-q+3pq)Y_{t-1}$$ Vous pouvez l'appliquer itérativement pour obtenir $$Y_t|Y_0=Y_0\prod_{j=1}^t (1-q+3qX_t)$$ avec la valeur attendue $$E(Y_t|Y_{0}) = (1-q+3pq)^t Y_{0}$$ vous pouvez également exprimer la quantité au temps$t$ en fonction d'une seule variable aléatoire$Z_t=\sum_{j=1}^t X_t\sim Binomial(t,p)$ , mais notant que$Z_t$ n'est pas indépendant de$Z_{t-1}$ $$Y_t|Y_0=Y_0 (1+2q)^{Z_t}(1-q)^{t-Z_t}$$

stratégie possible

vous pouvez utiliser cette formule pour déterminer une valeur de «faible risque» pour $q$ . Supposons que vous vouliez vous assurer qu'après $k$ pertes consécutives, vous disposiez toujours de la moitié de votre richesse d'origine. Ensuite, vous définissez $q=1-2^{-k^{-1}}$

En prenant l'exemple $k=5$ , nous fixons $q=0.129$ , ou avec $k=15$ nous fixons $q=0.045$ .

En outre, en raison de la nature récursive de la stratégie, ce risque correspond à ce que vous prenez à chaque pari. C'est-à-dire qu'au temps $s$ , en continuant à jouer, vous vous assurez qu'au temps $k+s$ votre richesse sera d'au moins $0.5Y_{s}$

discussion

la stratégie ci-dessus ne dépend pas du gain de la victoire, mais plutôt de la fixation d'une limite à la perte. Nous pouvons obtenir les gains attendus en substituant la valeur de $q$ nous avons calculée, et au moment $k$ qui a été utilisé en tenant compte du risque.

cependant, il est intéressant de regarder la médiane plutôt que la rentabilité attendue au temps $t$ , ce qui peut être trouvé en supposant que $median(Z_t)\approx tp$ .

$$Y_k|Y_0=Y_0 (1+2q)^{tp}(1-q)^{t(1-p)}$$ lorsque $p=0.5$ nous avons le rapport égal à $(1+q-2q^2)^{0.5t}$ . Ceci est maximisé lorsque$q=0.25$ et supérieur à$1$ lorsque$q<0.5$

il est également intéressant de calculer les chances que vous soyez en avance au temps $t$ . pour ce faire, nous devons déterminer la valeur $z$ telle sorte que

$$(1+2q)^{z}(1-q)^{t-z}>1$$ faisant un certain réarrangement, nous constatons que la proportion de victoires devrait satisfaire $$\frac{z}{t}>\frac{\log(1-q)}{\log(1-q)-\log(1+2q)}$$ Ceci peut être branché dans une approximation normale (note: moyenne de$0.5$et erreur standard de$\frac{0.5}{\sqrt{t}}$ ) comme $$Pr(\text{ahead at time t})\approx\Phi\left(\sqrt{t}\frac{\log(1+2q)+\log(1-q)}{\left[\log(1+2q)-\log(1-q)\right]}\right)$$

ce qui montre clairement que le jeu a de très bonnes chances. le facteur multipliant $\sqrt{t}$ est minimisé lorsque$q=0$(valeur maximisée de$\frac{1}{3}$ ) et décroît de façon monotone en fonction de$q$. la stratégie "à faible risque" consiste donc à miser une très petite fraction de votre richesse et à jouer un grand nombre de fois.

supposons que nous comparons cela avec $q=\frac{1}{3}$ et$q=\frac{1}{100}$ . le facteur pour chaque cas est de$0.11$et$0.32$. Cela signifie qu'après$38$matchs, vous auriez environ 95% de chances d'être en tête avec la petite mise, contre 75% avec la plus grosse mise. De plus, vous avez également une chance de faire faillite avec la mise la plus importante, en supposant que vous deviez arrondir votre mise au 5 cents ou au dollar le plus proche. À partir de$20$cela pourrait aller de$13.35, 8.90,5.95,3.95,2.65,1.75,1.15,0.75,0.50,0.35,0.25,0.15,0.1,0.05,0$ . Il s'agit d'une séquence de$14$ défaites sur$38$ , et étant donné que le jeu s'attend à$19$ défaites, si vous n'avez pas de chance avec les premiers paris, alors même gagner peut ne pas compenser une mauvaise séquence (par exemple, si la plupart de vos victoires se produisent une fois que la plupart des richesses ont disparu). la rupture avec la plus petite participation de 1% n'est pas possible en$38$ matchs. Le revers de la médaille est que la plus petite mise se traduira par un bénéfice beaucoup plus faible en moyenne, quelque chose comme uneaugmentation de$350$ fois avec la grosse mise par rapport à$1.2$ augmenter avec le petit pari (c'est-à-dire que vous vous attendez à avoir 24 dollars après 38 tours avec le petit pari et 7000 dollars avec le gros pari).

Je ne pense pas que ce soit très différent de la Martingale. Dans votre cas, il n'y a pas de paris doublés, mais le gain gagnant est de 3x.

J'ai codé une "réplique vivante" de votre arbre. Je lance 10 simulations. Dans chaque simulation (trace), vous commencez avec 200 pièces et essayez avec l'arbre, 1 pièce à chaque fois 20 000 fois.

Les seules conditions qui arrêtent la simulation sont la faillite ou avoir «survécu» à 20 000 tentatives

Je pense que quelles que soient les chances, la faillite vous attend tôt ou tard.

---

Le code est du javascript improvisé mais sans dépendance: https://repl.it/@cilofrapez/MagicTree-Roulette

Il vous montre immédiatement les résultats. Le code est simple à peaufiner: pour exécuter cependant autant de simulations, le montant des mises, autant de tentatives ... N'hésitez pas à jouer!

Au bas du code, les résultats de chaque simulation (par défaut 10) sont enregistrés dans un fichier CSV avec deux colonnes: numéro de rotation et argent. Je l'ai fait pour qu'il puisse être introduit dans un traceur en ligne pour les graphiques.

Il serait facile de tout automatiser localement en utilisant la bibliothèque Google Charts par exemple. Si vous voulez seulement voir les résultats à l'écran, vous pouvez commenter cette dernière partie comme je l'ai mentionné dans le fichier.

ÉDITER

Code source:

/**
 * License: MIT
 * Author: Carles Alcolea, 2019
 * Usage: I recommend using an online solution like repl.it to run this code.
 * Nonetheless, having node installed, it's as easy as running `node magicTree.js`.
 *
 * The code will run `simulations` number of scenarios, each scenario is equal in settings
 * which are self-descriptive: `betAmount`,`timesWinPayout`, `spinsPerSimulation`, `startingBankRoll`
 * and `winningOdds`.
 *
 * At the end of the code there's a part that will generate a *.csv file for each simulation run.
 * This is useful for ploting the resulting data using any such service or graphing library. If you
 * wish the code to generate the files for you, just set `saveResultsCSV` to true. All files will
 * have two columns: number of spin and current bankroll.
 */

const fs = require('fs'); // Only necessary if `saveResultsCSV` is true

/**
 * ==================================
 * You can play with the numbers of the following variables all you want:
 */
const betAmount          = 0.4,   // Percentage of bankroll that is offered to the tree
      winningOdds        = 0.5,
      startingBankRoll   = 200,
      timesWinPayout     = 2,
      simulations        = 5,
      spinsPerSimulation = 20000,
      saveResultsCSV     = false;
/**
 * ==================================
 */

const simWins = [];
let currentSim = 1;

//* Each simulation:
while (currentSim <= simulations) {
  let currentBankRoll = startingBankRoll,
      spin            = 0;
  const resultsArr  = [],
        progressArr = [];

  //* Each spin/bet:
  while (currentBankRoll > 0 && spin < spinsPerSimulation) {
    if (currentBankRoll === Infinity) break; // Can't hold more cash!
    let currentBet = Math.ceil(betAmount * currentBankRoll);
    if (currentBet > currentBankRoll) break;  // Can't afford more bets... bankrupt!

    const treeDecision = Math.random() < winningOdds;
    resultsArr.push(treeDecision);
    if (treeDecision) currentBankRoll += currentBet * timesWinPayout; else currentBankRoll -= currentBet;
    progressArr.push(currentBankRoll);
    spin++;
  }

  const wins = resultsArr.filter(el => el === true).length;
  const losses = resultsArr.filter(el => el === false).length;
  const didTheBankRollHold = (resultsArr.length === spinsPerSimulation) || currentBankRoll === Infinity;

  const progressPercent = didTheBankRollHold ? `(100%)` : `(Bankrupt at aprox ${((resultsArr.length / parseFloat(spinsPerSimulation)) * 100).toPrecision(4)}% progress)`;

  // Current simulation summary
  console.log(`
  - Simulation ${currentSim}: ${progressPercent === '(100%)' ? '✔' : '✘︎'}
    Total:      ${spin} spins out of ${spinsPerSimulation} ${progressPercent}
    Wins:       ${wins} (aprox ${((wins / parseFloat(resultsArr.length)) * 100).toPrecision(4)}%)
    Losses:     ${losses} (aprox ${((losses / parseFloat(resultsArr.length)) * 100).toPrecision(4)}%)
    Bankroll:   ${currentBankRoll}
  `);

  if (didTheBankRollHold) simWins.push(1);

  /**
   * ==================================
   * Saving data?
   */
  if (saveResultsCSV) {
    let data = `spinNumber, bankRoll`;
    if (!fs.existsSync('CSVresults')) fs.mkdirSync('CSVresults');
    progressArr.forEach((el, i) => {
      data += `\n${i + 1}, ${el}`;
    });
    fs.writeFileSync(`./CSVresults/results${currentSim}.csv`, data);
  }
  /**
   * ==================================
   */

  currentSim++;
}

// Total summary
console.log(`We ran ${simulations} simulations, with the goal of ${spinsPerSimulation} spins in each one.
Our bankroll (${startingBankRoll}) has survived ${simWins.length} out of ${simulations} simulations, with ${(1 - winningOdds) * 100}% chance of winning.`);
```

Énoncé du problème

Soit $Y_t = \log_{10}(M_t)$ le logarithme de la somme d'argent $M_t$ le joueur a au temps $t$ .

Soit $q$ la fraction d'argent que le joueur parie.

Soit $Y_0 = 1$ la somme d'argent avec laquelle le joueur commence (dix dollars). Soit $Y_L=-2$ le montant d'argent où le joueur fait faillite (en dessous de 1 cent). Pour simplifier, nous ajoutons une règle selon laquelle le joueur arrête de jouer lorsqu'il a dépassé une certaine somme d'argent $Y_W$ (nous pouvons ensuite lever cette règle en prenant la limite $Y_W \to \infty$ ).

Marche aléatoire

Vous pouvez voir la croissance et le déclin de l'argent comme une marche aléatoire asymétrique. Autrement dit, vous pouvez décrire $Y_t$ comme:

$$Y_t = Y_0 + \sum_{i=1}^t X_i$$

où

$$\mathbb{P}[X_i= a_w =\log(1+2q)] = \mathbb{P}[X_i= a_l =\log(1-q)] = \frac{1}{2}$$

Probabilité de faillite

Martingale

L'expression

$$Z_t = c^{Y_t}$$

est une martingale quand on choisit $c$ tel que.

$$c^{a_w}+ c^{a_l} = 2$$ $c<1$$q<0.5$

$$E[Z_{t+1}] = E[Z_t] \frac{1}{2} c^{a_w} + E[Z_t] \frac{1}{2} c^{a_l} = E[Z_t]$$

Probabilité de se retrouver en faillite

$Y_t < Y_L$$Y_t>Y_W$$\frac{Y_W-Y_L}{a_w}$

$E[Z_\tau]$$\tau$$E[Z_0]$

Donc

$$c^{Y_0} = E[Z_0] = E[Z_\tau] \approx \mathbb{P}[Y_\tau<L] c^{Y_L} + (1-\mathbb{P}[Y_\tau<L]) c^{Y_W}$$

et

$$\mathbb{P}[Y_\tau<Y_L] \approx \frac{c^{Y_0}-c^{Y_W}}{c^{Y_L}-c^{Y_W}}$$

and the limit $Y_W \to \infty$

$$\mathbb{P}[Y_\tau<Y_L] \approx c^{Y_0-Y_L}$$

Conclusions

Is there an optimal percentage of your cash you can offer without losing it all?

Whichever is the optimal percentage will depend on how you value different profits. However, we can say something about the probability to lose it all.

Only when the gambler is betting zero fraction of his money then he will certainly not go bankrupt.

With increasing $q$ the probability to go bankrupt will increase up to some point where the gambler will almost surely go bankrupt within a finite time (the gambler's ruin mentioned by Robert Long in the comments). This point, $q_{\text{gambler's ruin}}$, is at

$$q_{\text{gambler's ruin}} = 1-1/b$$ This is the point where there is no solution for $c$ below one. This is also the point where the increasing steps $a_w$ are smaller than the decreasing steps $a_l$.

Thus, for $b=2$, as long as the gambler bets less than half the money then the gambler will not certainly go bankrupt.

do the odds of losing all your money decrease or increase over time?

The probability to go bankrupt is dependent on the distance from the amount of money where the gambler goes bankrupt. When $q<q_{\text{gambler's ruin}}$ the gambler's money will, on average increase, and the probability to go bankrupt will, on average, decrease.

Bankruptcy probability when using the Kelly criterion.

When you use the Kelly criterion mentioned in Dave Harris answer, $q = 0.5(1-1/b)$, for $b$ being the ratio between loss and profit in a single bet, then independent from $b$ the value of $c$ will be equal to $0.1$ and the probability to go bankrupt will be $0.1^{S-L}$.

That is, independent from the assymetry parameter $b$ of the magic tree, the probability to go bankrupt, when using the Kelly criterion, is equal to the ratio of the amount of money where the gambler goes bankrupt and the amount of money that the gambler starts with. For ten dollars and 1 cent this is a 1:1000 probability to go bankrupt, when using the Kelly criterion.

Simulations

The simulations below show different simulated trajectories for different gambling strategies. The red trajectories are ones that ended up bankrupt (hit the line $Y_t=-2$).

Distribution of profits after time $t$

To further illustrate the possible outcomes of gambling with the money tree, you can model the distribution of $Y_t$ as a one dimensional diffusion process in a homogeneous force field and with an absorbing boundary (where the gambler get's bankrupt). The solution for this situation has been given by Smoluchowski

Smoluchowski, Marian V. "Über Brownsche Molekularbewegung unter Einwirkung äußerer Kräfte und deren Zusammenhang mit der verallgemeinerten Diffusionsgleichung." Annalen der Physik 353.24 (1916): 1103-1112. (online available via: https://www.physik.uni-augsburg.de/theo1/hanggi/History/BM-History.html)

Equation 8:

$$W(x_0,x,t) = \frac{e^{-\frac{c(x-x_0)}{2D} - \frac{c^2 t}{4D}}}{2 \sqrt{\pi D t}} \left[ e^{-\frac{(x-x_0)^2}{4Dt}} - e^{-\frac{(x+x_0)^2}{4Dt}} \right]$$

This diffusion equation relates to the tree problem when we set the speed $c$ equal to the expected increase $E[Y_t]$, we set $D$ equal to the variance of the change in a single steps $\text{Var}(X_t)$, $x_0$ is the initial amount of money, and $t$ is the number of steps.

The image and code below demonstrate the equation:

• The histogram shows the result from a simulation.

• The dotted line shows a model when we use a naive normal distribution to approximate the distribution (this corresponds to the absence of the absorbing 'bankruptcy' barrier). This is wrong because some of the results above the bankruptcy level involve trajectories that have passed the bankruptcy level at an earlier time.

• The continuous line is the approximation using the formula by Smoluchowski.

Codes

#
## Simulations of random walks and bankruptcy:
#

# functions to compute c
cx = function(c,x) {
  c^log(1-x,10)+c^log(1+2*x,10) - 2
}
findc = function(x) {
  r <- uniroot(cx, c(0,1-0.1^10),x=x,tol=10^-130)
  r$root
}


# settings
set.seed(1)
n <- 100000
n2 <- 1000
q <- 0.45

# repeating different betting strategies
for (q in c(0.35,0.4,0.45)) {
  # plot empty canvas
  plot(1,-1000,
       xlim=c(0,n2),ylim=c(-2,50),
       type="l",
       xlab = "time step", ylab = expression(log[10](M[t])) )

  # steps in the logarithm of the money
  steps <- c(log(1+2*q,10),log(1-q,10))

  # counter for number of bankrupts
  bank <- 0

  # computing 1000 times
  for (i in 1:1000) {
    # sampling wins or looses
    X_t <- sample(steps, n, replace = TRUE)
    # compute log of money
    Y_t <- 1+cumsum(X_t)
    # compute money
    M_t <- 10^Y_t
    # optional stopping (bankruptcy)
    tau <- min(c(n,which(-2 > Y_t)))
    if (tau<n) {
      bank <- bank+1
    }
    # plot only 100 to prevent clutter
    if (i<=100) {
      col=rgb(tau<n,0,0,0.5)
      lines(1:tau,Y_t[1:tau],col=col)
    }
  }
  text(0,45,paste0(bank, " bankruptcies out of 1000 \n", "theoretic bankruptcy rate is ", round(findc(q)^3,4)),cex=1,pos=4)
  title(paste0("betting a fraction ", round(q,2)))
}

#
## Simulation of histogram of profits/results
#

# settings
set.seed(1)
rep <- 10000  # repetitions for histogram
n   <- 5000   # time steps
q   <- 0.45    # betting fraction
b   <- 2      # betting ratio loss/profit
x0  <- 3      # starting money

# steps in the logarithm of the money
steps <- c(log(1+b*q,10),log(1-q,10))

# to prevent Moiré pattern in
# set binsize to discrete differences in results
binsize <- 2*(steps[1]-steps[2]) 

for (n in c(200,500,1000)) {

  # computing several trials
  pays <- rep(0,rep)
  for (i in 1:rep) {
    # sampling wins or looses
    X_t <- sample(steps, n, replace = TRUE)
      # you could also make steps according to a normal distribution
      # this will give a smoother histogram
      # to do this uncomment the line below
    # X_t <- rnorm(n,mean(steps),sqrt(0.25*(steps[1]-steps[2])^2))

    # compute log of money
    Y_t <- x0+cumsum(X_t)
    # compute money
    M_t <- 10^Y_t
    # optional stopping (bankruptcy)
    tau <- min(c(n,which(Y_t < 0)))
    if (tau<n) {
      Y_t[n] <- 0
      M_t[n] <- 0
    }
    pays[i] <- Y_t[n]
  }

  # histogram
  h <- hist(pays[pays>0],
            breaks = seq(0,round(2+max(pays)),binsize), 
            col=rgb(0,0,0,0.5),
            ylim=c(0,1200),
            xlab = "log(result)", ylab = "counts",
            main = "")
  title(paste0("after ", n ," steps"),line = 0)  

  # regular diffusion in a force field (shifted normal distribution)
  x <- h$mids
  mu <- x0+n*mean(steps)
  sig <- sqrt(n*0.25*(steps[1]-steps[2])^2)
  lines(x,rep*binsize*(dnorm(x,mu,sig)), lty=2)

  # diffusion using the solution by Smoluchowski
  #   which accounts for absorption
  lines(x,rep*binsize*Smoluchowski(x,x0,0.25*(steps[1]-steps[2])^2,mean(steps),n))

}