24 votos

El problema del árbol mágico del dinero

Se me ocurrió este problema en la ducha, inspirado en las estrategias de inversión.

Digamos que existe un árbol mágico del dinero. Cada día, puedes ofrecer una cantidad de dinero al árbol del dinero y éste la triplicará o la destruirá con una probabilidad del 50/50. Inmediatamente te das cuenta de que, por término medio, ganarás dinero haciendo esto y estás deseando aprovecharte del árbol del dinero. Sin embargo, si ofrecieras todo tu dinero a la vez, tendrías un 50% de posibilidades de perderlo todo. ¡Inaceptable! Eres una persona bastante reacia al riesgo, así que decides idear una estrategia. Quieres minimizar las probabilidades de perderlo todo, pero también quieres ganar tanto dinero como puedas. Se te ocurre lo siguiente: cada día, ofreces el 20% de tu capital actual al árbol del dinero. Suponiendo que lo mínimo que puedes ofrecer es 1 céntimo, necesitarías una racha de 31 pérdidas para perder todo tu dinero si empezaste con 10 dólares. Es más, cuanto más dinero ganes, más larga tendrá que ser la racha de pérdidas para que lo pierdas todo, ¡asombroso! Rápidamente empiezas a ganar mucho dinero. Pero entonces se te ocurre una idea: ¡puedes ofrecer un 30% cada día y ganar mucho más dinero! Pero espera, ¿por qué no ofrecer un 35%? 50%? Un día, con un gran signo de dólar en los ojos, corres hacia el árbol del dinero con todos tus millones y ofreces el 100% de tu dinero, que el árbol quema inmediatamente. Al día siguiente consigues trabajo en McDonalds.

¿Existe un porcentaje óptimo de su efectivo que pueda ofrecer sin perderlo todo?

(sub) preguntas:

Si hay un porcentaje óptimo que deberías ofrecer, ¿es estático (es decir, un 20% cada día) o debería crecer a medida que aumenta tu capital?

Al ofrecer un 20% cada día, ¿disminuyen o aumentan con el tiempo las probabilidades de perder todo el dinero? ¿Existe un porcentaje de dinero a partir del cual las probabilidades de perder todo el dinero aumentan con el tiempo?

23voto

Jay Querido Puntos 589

Se trata de un problema bien conocido. Se llama apuesta de Kelly. La respuesta, por cierto, es 1/3. Es equivalente a maximizar la utilidad logarítmica de la riqueza.

Kelly empezó llevando el tiempo hasta el infinito y luego resolviendo hacia atrás. Como siempre se pueden expresar los rendimientos en términos de capitalización continua, también se puede invertir el proceso y expresarlo en logaritmos. Voy a utilizar la explicación de la utilidad logarítmica, pero la utilidad logarítmica es una conveniencia. Si usted está maximizando la riqueza como $n\to\infty$ entonces usted va a terminar con una función que resulta ser el mismo que log utilidad. Si $b$ son las probabilidades de pago, y $p$ es la probabilidad de ganar, y $X$ es el porcentaje de riqueza invertido, entonces funcionará la siguiente derivación.

Para una apuesta binaria, $E(\log(X))=p\log(1+bX)+(1-p)\log(1-X)$ para un período y una riqueza unitarios.

$$\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}$$

Poner la derivada a cero para encontrar los extremos,

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

Multiplicando en cruz, se obtiene $$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}$$

En tu caso, $$X=\frac{3\times\frac{1}{2}-(1-\frac{1}{2})}{3}=\frac{1}{3}.$$

Esto se puede ampliar fácilmente a resultados múltiples o continuos resolviendo la utilidad esperada de la riqueza sobre una distribución de probabilidad conjunta, eligiendo las asignaciones y sujeto a cualquier restricción. Curiosamente, si se realiza de esta manera, incluyendo restricciones, como la capacidad de hacer frente a los pagos de la hipoteca, etc., entonces se ha tenido en cuenta el conjunto total de riesgos y se tiene una solución ajustada al riesgo o, al menos, con riesgo controlado.

Desiderata El propósito real de la investigación original tenía que ver con cuánto apostar basándose en una señal ruidosa. En el caso concreto, cuánto apostar por una señal electrónica ruidosa que indicaba el lanzamiento de armas nucleares por parte de la Unión Soviética. Tanto Estados Unidos como Rusia han estado a punto de realizar varios lanzamientos, obviamente por error. ¿Cuánto apostar por una señal?

6voto

ychemama Puntos 16

No creo que esto sea muy diferente de la Martingala. En tu caso, no hay apuestas dobles, pero el pago ganador es 3x.

He codificado una "réplica viviente" de tu árbol. Ejecuto 10 simulaciones. En cada simulación (traza), empiezas con 200 monedas y pruebas con el árbol, 1 moneda cada vez durante 20.000 veces.

Las únicas condiciones que detienen la simulación son la quiebra o haber "sobrevivido" a 20.000 intentos.

enter image description here

Creo que, sean cuales sean las probabilidades, tarde o temprano te espera la quiebra.


El código es javascript improvisado pero sin dependencias: https://repl.it/@cilofrapez/MagicTree-Roulette

Te muestra los resultados inmediatamente. El código es fácil de modificar: para realizar el número de simulaciones, el importe de la apuesta, el número de intentos... ¡Siéntase libre de jugar!

Al final del código, los resultados de cada simulación (por defecto 10) se guardan en un archivo CSV con dos columnas: número de giro y dinero. Lo hice para que pudiera ser alimentado a un trazador en línea para los gráficos.

No supondría ningún esfuerzo automatizarlo todo localmente utilizando la biblioteca de Google Charts, por ejemplo. Si sólo quieres ver los resultados en la pantalla, puedes comentar esa última parte como mencioné en el archivo.

EDITAR

Código fuente:

/**
 * 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.`);
```

5voto

user164061 Puntos 281

Planteamiento del problema

  • $\mathbf{M_t}$ : la cantidad de dinero $M_t$ el jugador tiene en el momento $t$
  • $\mathbf{Y_t}$ : Sea $Y_t = \log_{10}(M_t)$ sea el logaritmo de $M_t$ .
  • $\mathbf{Y_0}$ : Sea $Y_0 = 1$ es la cantidad de dinero con la que empieza el jugador (diez dólares).
  • $\mathbf{Y_L}$ : Sea $Y_L=-2$ sea la cantidad de dinero en la que el apostante quiebra (por debajo de 1 céntimo).
  • $\mathbf{Y_W}$ : Para simplificar añadimos una regla según la cual el jugador deja de apostar cuando ha pasado cierta cantidad de dinero $Y_W$ (más adelante podemos levantar esta regla tomando el límite $Y_W \to \infty$ ).
  • $\mathbf{q}$ : Sea $q$ sea la fracción de dinero que apuesta el jugador.
  • $\mathbf{b}$ : Sea $b$ es la relación entre la ganancia y la pérdida. En este caso, una ganancia es el doble de la apuesta $q$ y una pérdida es una vez la apuesta $q$ Así que $b = 2$ .
  • $\mathbf{X_i}$ : La variación del logaritmo de la cantidad de dinero en el $i$ -th gamble. $X_i = Y_t-Y_{t-1}$
  • $\mathbf{a_w}$ : $X$ para ganar.
  • $\mathbf{a_l}$ : $X$ por una pérdida.

Paseo aleatorio

Se puede ver el crecimiento y el declive del dinero como un paseo aleatorio asimétrico. Es decir, se puede describir $Y_t$ como:

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

donde

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

Probabilidad de quiebra

Martingala

La expresión

$$Z_t = c^{Y_t}$$

es una martingala cuando elegimos $c$ tal que.

$$c^{a_w}+ c^{a_l} = 2$$ (donde $c<1$ si $q<0.5$ ). Puesto que en ese caso

$$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]$$

Probabilidad de acabar en quiebra

El tiempo de parada (pérdida/quiebra $Y_t < Y_L$ o ganar $Y_t>Y_W$ ) es casi seguramente finito ya que requiere en el peor de los casos una racha ganadora (o perdedora) de cierta longitud finita, $\frac{Y_W-Y_L}{a_w}$ que es casi seguro que va a suceder.

A continuación, podemos utilizar la función teorema de parada opcional decir $E[Z_\tau]$ en el momento de la parada $\tau$ es igual al valor esperado $E[Z_0]$ en el momento cero.

Así

$$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}$$

y

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

y el límite $Y_W \to \infty$

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

Conclusiones

¿Existe un porcentaje óptimo de su efectivo que pueda ofrecer sin perderlo todo?

Cuál sea el porcentaje óptimo dependerá de cómo valores los distintos beneficios. Sin embargo, podemos decir algo sobre la probabilidad de perderlo todo.

Sólo cuando el jugador está apostando cero fracción de su dinero, entonces ciertamente no irá a la quiebra.

Con el aumento $q$ la probabilidad de quebrar aumentará hasta un punto en el que el jugador quebrará casi con toda seguridad en un plazo finito (la ruina del jugador mencionada por Robert Long en los comentarios). Este punto, $q_{\text{gambler's ruin}}$ está en $$q_{\text{gambler's ruin}} = 1-1/b$$ Este es el punto en el que no hay solución para $c$ debajo de uno. Este es también el punto en el que los pasos crecientes $a_w$ son menores que los escalones decrecientes $a_l$ .

Así, para $b=2$ siempre que el jugador apueste menos de la mitad del dinero, entonces el jugador no sin duda quebrar.

¿las probabilidades de perder todo tu dinero disminuyen o aumentan con el tiempo?

La probabilidad de quebrar depende de la distancia de la cantidad de dinero a la que el jugador quiebra. Cuando $q<q_{\text{gambler's ruin}}$ el dinero del jugador aumentará, por término medio, y la probabilidad de quebrar disminuirá, por término medio.

Probabilidad de quiebra cuando se utiliza el criterio de Kelly.

Cuando se utiliza el criterio Kelly mencionado en la respuesta de Dave Harris, $q = 0.5(1-1/b)$ para $b$ siendo la relación entre pérdidas y ganancias en una sola apuesta, entonces independiente de $b$ el valor de $c$ será igual a $0.1$ y la probabilidad de quebrar será $0.1^{Y_0-Y_L}$ ....


Derivación: si $c=0.1$ con $a_w = \log_{10}(1+bq)$ y $a_l = \log_{10}(1-q)$ entonces $$c^{a_w}+c^{a_l} = 0.1^{\log(1+bq)}+0.1^{\log(1-q)} = \frac{1}{1+bq} + \frac{1}{1-q} $$ que es igual a 2 cuando rellenamos $q=0.5\frac{b-1}{b}$ .


...Es decir, independiente del parámetro de asimetría $b$ del árbol mágico, la probabilidad de quebrar, cuando se utiliza el criterio de Kelly, es igual a la relación entre la cantidad de dinero con la que el jugador quiebra y la cantidad de dinero con la que el jugador empieza. Para diez dólares y un céntimo, la probabilidad de quebrar es de 1:1000, utilizando el criterio de Kelly.

Simulaciones

Las simulaciones siguientes muestran diferentes trayectorias simuladas para diferentes estrategias de juego. Las trayectorias en rojo son las que terminaron en bancarrota (alcanzaron la línea $Y_t=-2$ ).

simulations

Distribución de beneficios al cabo del tiempo $t$

Para ilustrar mejor los posibles resultados de apostar con el árbol del dinero, se puede modelar la distribución de $Y_t$ como un proceso de difusión unidimensional en un campo de fuerzas homogéneo y con una frontera absorbente (donde el jugador se arruina). La solución para esta situación ha sido dada por Smoluchowski

Smoluchowski, Marian V. "Sobre el movimiento molecular browniano bajo la acción de fuerzas externas y su relación con la ecuación de difusión generalizada". Annalen der Physik 353.24 (1916): 1103-1112. (disponible en línea a través de: https://www.physik.uni-augsburg.de/theo1/hanggi/History/BM-History.html )

Ecuación 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]$$

Esta ecuación de difusión se relaciona con el problema del árbol cuando fijamos la velocidad $c$ igual al aumento previsto $E[Y_t]$ fijamos $D$ igual a la varianza del cambio en un solo paso $\text{Var}(X_t)$ , $x_0$ es la cantidad inicial de dinero, y $t$ es el número de pasos.

La imagen y el código siguientes muestran la ecuación:

  • El histograma muestra el resultado de una simulación.

  • La línea de puntos muestra un modelo cuando utilizamos una distribución normal ingenua para aproximar la distribución (esto corresponde a la ausencia de la barrera absorbente "quiebra"). Esto es erróneo porque algunos de los resultados por encima del nivel de quiebra implican trayectorias que han superado el nivel de quiebra en un momento anterior.

  • La línea continua es la aproximación mediante la fórmula de Smoluchowski.

illustration as diffusion in force field

Códigos

#
## 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))

}

i-Ciencias.com

I-Ciencias es una comunidad de estudiantes y amantes de la ciencia en la que puedes resolver tus problemas y dudas.
Puedes consultar las preguntas de otros usuarios, hacer tus propias preguntas o resolver las de los demás.

Powered by:

X