Myślałem o tym problemie pod prysznicem, ponieważ inspiracją były strategie inwestycyjne.

Powiedzmy, że było drzewo magicznych pieniędzy. Każdego dnia możesz zaoferować pieniądze drzewku pieniędzy, które potroi je lub zniszczy z prawdopodobieństwem 50/50. Natychmiast zauważasz, że robiąc to, średnio zarabiasz i chętnie skorzystasz z drzewa pieniędzy. Jeśli jednak zaoferowałbyś wszystkie swoje pieniądze naraz, miałbyś 50% utraty wszystkich pieniędzy. Gorszący! Jesteś osobą dość unikającą ryzyka, więc decydujesz się na strategię. Chcesz zminimalizować szanse na utratę wszystkiego, ale chcesz też zarobić jak najwięcej pieniędzy! Pojawiają się następujące rzeczy: każdego dnia oferujesz drzewku pieniędzy 20% swojego obecnego kapitału. Zakładając, że najniższa kwota, jaką możesz zaoferować, to 1 cent, zajęłoby to 31 strat, aby stracić wszystkie pieniądze, gdybyś zaczął od 10 dolarów. Co więcej, im więcej zarobisz gotówki, tym dłużej musi trwać przegrana, abyś stracił wszystko, niesamowite! Szybko zaczniesz zarabiać mnóstwo gotówki. Ale wtedy pojawia się pomysł: możesz zaoferować 30% każdego dnia i zarobić znacznie więcej pieniędzy! Ale czekaj, dlaczego nie zaoferować 35%? 50% Pewnego dnia, mając wielkie znaki dolara w oczach, podbiegasz do drzewa pieniędzy ze wszystkimi milionami i oferujesz 100% gotówki, którą drzewo pieniędzy natychmiast płonie. Następnego dnia dostaniesz pracę w McDonalds. które drzewo pieniędzy natychmiast pali. Następnego dnia dostaniesz pracę w McDonalds. które drzewo pieniędzy natychmiast pali. Następnego dnia dostaniesz pracę w McDonalds.

Czy istnieje optymalny procent gotówki, który możesz zaoferować, nie tracąc wszystkiego?

(pod) pytania:

Jeśli istnieje optymalny odsetek, który powinieneś zaoferować, czy jest on stały (tj. 20% każdego dnia), czy też odsetek ten powinien rosnąć w miarę wzrostu kapitału?

Czy oferując codziennie 20%, szanse na utratę wszystkich pieniędzy zmniejszają się lub rosną z czasem? Czy istnieje procent pieniędzy, z którego prawdopodobieństwo utraty wszystkich pieniędzy rośnie z czasem?

To dobrze znany problem. Nazywa się to zakładem Kelly. Nawiasem mówiąc, odpowiedź to 1/3. Jest to równoważne z maksymalizacją użyteczności dzienników bogactwa.

Kelly zaczął od poświęcenia czasu na nieskończoność, a następnie na rozwiązanie problemu. Ponieważ zawsze możesz wyrażać zwroty w postaci ciągłego łączenia, możesz także odwrócić proces i wyrazić go w logach. Mam zamiar użyć wyjaśnienia narzędzia dziennika, ale narzędzie dziennika jest wygodą. Jeśli maksymalizujesz bogactwo jako $n\to\infty$ , skończysz z funkcją, która działa tak samo jak narzędzie dziennika. Jeśli $b$ jest szansą na wypłatę, a $p$ jest prawdopodobieństwem wygranej, a $X$ jest procentem zainwestowanego bogactwa, wówczas zadziała następująca pochodna.

W przypadku zakładu binarnego $E(\log(X))=p\log(1+bX)+(1-p)\log(1-X)$ , dla pojedynczego okresu i bogactwa jednostki.

Ustawienie pochodnej na zero, aby znaleźć skrajność,

Mnożenie krzyżowe, otrzymujesz

W twoim przypadku

Możesz z łatwością rozszerzyć to na wiele lub ciągłe wyniki, rozwiązując oczekiwaną użyteczność bogactwa w stosunku do wspólnego rozkładu prawdopodobieństwa, wybierając przydziały i poddając się wszelkim ograniczeniom. Co ciekawe, jeśli wykonujesz to w ten sposób, włączając ograniczenia, takie jak zdolność do spłacania kredytów hipotecznych i tak dalej, to rozliczyłeś cały zestaw ryzyk, a więc masz skorygowane o ryzyko lub przynajmniej kontrolowane ryzyko rozwiązanie.

Desiderata Rzeczywisty cel pierwotnych badań miał związek z tym, ile hazardu można uzyskać na podstawie głośnego sygnału. W konkretnym przypadku, ile ryzykować za pomocą hałaśliwego sygnału elektronicznego, gdy wskazywał on na wystrzelenie broni nuklearnej przez Związek Radziecki. Było kilka zbliżających się premier zarówno przez Stany Zjednoczone, jak i Rosję, oczywiście w błędzie. Ile grasz na sygnał?

Podobała mi się odpowiedź Dave'a Harrisa. choć podejdę do tego problemu z perspektywy „niskiego ryzyka”, zamiast maksymalizować zysk

Losowy spacer, który wykonujesz, zakładając, że twój ułamek jest $q$ a prawdopodobieństwo wygranej $p=0.5$ podano jako

możliwa strategia

możesz użyć tej formuły, aby określić wartość „niskiego ryzyka” dla $q$ . Załóżmy, że chcesz mieć pewność, że po $k$ kolejnych stratach nadal masz połowę pierwotnego bogactwa. Następnie ustaw $q=1-2^{-k^{-1}}$

Biorąc przykład $k=5$ oznacza, że ​​ustawiamy $q=0.129$ , lub przy $k=15$ ustawiamy $q=0.045$ .

Ponadto, ze względu na rekurencyjny charakter strategii, ryzyko to jest podejmowane przy każdym zakładzie. Oznacza to, że na czas $s$ , kontynuując grać Jesteś zapewnienie, że w chwili $k+s$ Twój majątek będzie co najmniej $0.5Y_{s}$

dyskusja

powyższa strategia nie zależy od wypłaty wygranej, ale raczej od wyznaczenia granicy przegranej. Oczekiwaną wygraną możemy uzyskać, zastępując obliczoną przez nas wartość $q$ oraz w momencie $k$ który został użyty z uwzględnieniem ryzyka.

interesujące jest jednak spojrzenie na medianę, a nie spodziewaną spłatę w czasie $t$ , co można znaleźć, zakładając, że $median(Z_t)\approx tp$ .

interesujące jest również obliczenie szansy, że będziesz w czasie $t$ . w tym celu musimy wyznaczyć wartość $z$ tak aby

co wyraźnie pokazuje, że gra ma bardzo dobre szanse. współczynnik mnożący $\sqrt{t}$ jest zminimalizowane, gdy$q=0$(zmaksymalizowana wartość$\frac{1}{3}$ ) i zmniejsza się monotonicznie w funkcji$q$. więc strategia „niskiego ryzyka” polega na obstawianiu bardzo małej części swojego bogactwa i graniu dużej liczby razy.

załóżmy, że porównujemy to z $q=\frac{1}{3}$ i$q=\frac{1}{100}$ . współczynnik dla każdego przypadku wynosi$0.11$i$0.32$. Oznacza to, że po$38$meczach masz około 95% szansy na przewagę przy małym zakładzie, w porównaniu z 75% szansą na większy zakład. Ponadto masz również szansę na złamanie większego zakładu, zakładając, że musisz zaokrąglić stawkę do najbliższych 5 centów lub dolara. Począwszy od$20$może to$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$ . Jest to sekwencja$14$ przegranych z$38$ , a biorąc pod uwagę, że gra oczekiwałaby$19$ przegranych, jeśli nie będziesz miał szczęścia w pierwszych kilku zakładach, to nawet wygrana może nie zrekompensować złej passy (np. Jeśli większość twoich zwycięstw ma miejsce po zniknięciu większości bogactwa). zerwanie z mniejszym 1% udziałem nie jest możliwe w$38$ grach. Drugą stroną jest to, że mniejsza stawka przyniesie średnio znacznie mniejszy zysk, coś w rodzaju$350$ krotnego wzrostu przy dużym zakładzie w porównaniu do$1.2$ wzrost z małym zakładem (tzn. spodziewasz się 24 dolarów po 38 rundach z małym zakładem i 7000 dolarów z dużym zakładem).

Nie sądzę, że różni się to znacznie od Martingale. W twoim przypadku nie ma zakładów podwajających, ale wygrana to 3x.

Zakodowałem „żywą replikę” twojego drzewa. Przeprowadzam 10 symulacji. W każdej symulacji (ślad) zaczynasz z 200 monetami i próbujesz z drzewem, 1 monetą za każdym razem 20 000 razy.

Jedynymi warunkami, które zatrzymują symulację, są bankructwo lub „przetrwanie” 20 000 prób

Myślę, że niezależnie od szans, prędzej czy później bankructwo czeka na ciebie.

Kod jest improwizowanym javascript, ale bez zależności: https://repl.it/@cilofrapez/MagicTree-Roulette

Od razu pokazuje wyniki. Kod jest łatwy do poprawienia: uruchomić dowolną liczbę symulacji, kwotę zakładu, jednak wiele prób ... Zapraszam do gry!

W dolnej części kodu wyniki każdej symulacji (domyślnie 10) są zapisywane w pliku CSV z dwiema kolumnami: liczba obrotów i pieniądze. Zrobiłem to, aby można go było podawać do internetowego plotera do wykresów.

Łatwo byłoby zautomatyzować to wszystko lokalnie za pomocą na przykład biblioteki Google Charts. Jeśli chcesz tylko zobaczyć wyniki na ekranie, możesz skomentować ostatnią część, jak wspomniałem w pliku.

EDYTOWAĆ

Kod źródłowy:

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

Opis problemu

$Y_t = \log_{10}(M_t)$$M_t$$t$

$q$

$Y_0 = 1$$Y_L=-2$$Y_W$$Y_W \to \infty$

Losowy spacer

$Y_t$

gdzie

Prawdopodobieństwo bankructwa

Martingale

Ekspresja

$c$

Prawdopodobieństwo bankructwa

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

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

A zatem

i

$Y_W \to \infty$

Wnioski

Czy istnieje optymalny procent gotówki, który możesz zaoferować, nie tracąc wszystkiego?

Niezależnie od tego, który procent będzie optymalny, zależy od tego, jak wyceniasz różne zyski. Możemy jednak powiedzieć coś o prawdopodobieństwie utraty wszystkiego.

Tylko wtedy, gdy gracz obstawia zerową część swoich pieniędzy, z pewnością nie zbankrutuje.

$q$$q_{\text{gambler's ruin}}$

$b=2$

czy szanse na utratę wszystkich pieniędzy zmniejszają się lub rosną z czasem?

$q<q_{\text{gambler's ruin}}$

Prawdopodobieństwo bankructwa przy zastosowaniu kryterium Kelly'ego.

$q = 0.5(1-1/b)$$b$$b$$c$$0.1$$0.1^{S-L}$

$b$

Symulacje

$Y_t=-2$

$t$

$Y_t$

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. (dostępny online za pośrednictwem: https://www.physik.uni-augsburg.de/theo1/hanggi/History/BM-History.html )

Równanie 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]$$

$c$$E[Y_t]$$D$$\text{Var}(X_t)$$x_0$$t$

Poniższy obraz i kod pokazują równanie:

• Histogram pokazuje wynik symulacji.

• Linia kropkowana pokazuje model, gdy używamy naiwnego rozkładu normalnego do przybliżenia rozkładu (odpowiada to brakowi absorbującej bariery „bankructwa”). Jest to błędne, ponieważ niektóre wyniki powyżej poziomu upadłości obejmują trajektorie, które przekroczyły poziom bankructwa wcześniej.

• Linia ciągła jest przybliżeniem przy użyciu formuły Smoluchowskiego.

Kody

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

}