Saya memikirkan masalah ini di kamar mandi, itu terinspirasi oleh strategi investasi.

Katakanlah ada pohon uang ajaib. Setiap hari, Anda dapat menawarkan sejumlah uang ke pohon uang dan itu akan melipatgandakannya, atau menghancurkannya dengan probabilitas 50/50. Anda segera melihat bahwa rata-rata Anda akan mendapatkan uang dengan melakukan ini dan ingin mengambil keuntungan dari pohon uang. Namun, jika Anda menawarkan semua uang Anda sekaligus, Anda akan kehilangan 50% dari semua uang Anda. Tidak bisa diterima Anda adalah orang yang sangat menghindari risiko, sehingga Anda memutuskan untuk membuat strategi. Anda ingin meminimalkan kemungkinan kehilangan segalanya, tetapi Anda juga ingin menghasilkan uang sebanyak yang Anda bisa! Anda datang dengan yang berikut: setiap hari, Anda menawarkan 20% dari modal Anda saat ini ke pohon uang. Dengan asumsi harga terendah yang dapat Anda tawarkan adalah 1 sen, akan dibutuhkan kerugian beruntun 31 untuk kehilangan semua uang Anda jika Anda mulai dengan 10 dolar. Apalagi, semakin banyak uang yang Anda hasilkan, semakin lama semakin banyak kerugian yang harus Anda tanggung, menakjubkan! Anda dengan cepat mulai mendapatkan banyak uang. Tapi kemudian sebuah ide muncul di kepala Anda: Anda hanya bisa menawarkan 30% setiap hari dan menghasilkan lebih banyak uang! Tapi tunggu, mengapa tidak menawarkan 35%? 50%? Suatu hari, dengan tanda-tanda dolar besar di mata Anda, Anda berlari ke pohon uang dengan semua jutaan Anda dan menawarkan hingga 100% dari uang tunai Anda, yang pohon uang segera membakar. Hari berikutnya Anda mendapatkan pekerjaan di McDonalds. yang pohon uang segera bakar. Hari berikutnya Anda mendapatkan pekerjaan di McDonalds. yang pohon uang segera bakar. Hari berikutnya Anda mendapatkan pekerjaan di McDonalds.

Apakah ada persentase optimal dari uang tunai yang dapat Anda tawarkan tanpa kehilangan semuanya?

(sub) pertanyaan:

Jika ada persentase optimal yang harus Anda tawarkan, apakah ini statis (yaitu 20% setiap hari) atau haruskah persentase itu bertambah ketika modal Anda meningkat?

Dengan menawarkan 20% setiap hari, apakah peluang kehilangan semua uang Anda berkurang atau bertambah seiring waktu? Apakah ada persentase uang dari mana kemungkinan kehilangan semua uang Anda meningkat seiring waktu?

Ini adalah masalah yang terkenal. Ini disebut taruhan Kelly. Omong-omong, jawabannya adalah 1/3. Ini setara dengan memaksimalkan utilitas log kekayaan.

Kelly mulai dengan meluangkan waktu hingga tak terbatas dan kemudian mundur. Karena Anda selalu dapat mengekspresikan pengembalian dalam hal peracikan berkelanjutan, maka Anda juga dapat membalikkan proses dan mengekspresikannya dalam log. Saya akan menggunakan penjelasan utilitas log, tetapi utilitas log adalah kenyamanan. Jika Anda memaksimalkan kekayaan sebagai $n\to\infty$ maka Anda akan memiliki fungsi yang sama dengan utilitas log. Jika $b$ adalah peluang pembayaran, dan $p$ adalah probabilitas menang, dan $X$ adalah persentase kekayaan yang diinvestasikan, maka derivasi berikut akan bekerja.

Untuk taruhan biner, $E(\log(X))=p\log(1+bX)+(1-p)\log(1-X)$ , untuk periode tunggal dan kekayaan unit.

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

Mengatur turunan ke nol untuk menemukan ekstrema,

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

Mengalikan silang, Anda berakhir dengan

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

Dalam kasus Anda,

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

Anda dapat dengan mudah memperluas ini ke hasil yang berlipat ganda atau berkelanjutan dengan menyelesaikan utilitas kekayaan yang diharapkan dari distribusi probabilitas bersama, memilih alokasi dan tunduk pada kendala apa pun. Menariknya, jika Anda melakukannya dengan cara ini, dengan memasukkan kendala, seperti kemampuan untuk memenuhi pembayaran hipotek dan sebagainya, maka Anda telah memperhitungkan total risiko Anda dan karenanya Anda memiliki risiko yang disesuaikan atau setidaknya dikendalikan risiko. larutan.

Desiderata Tujuan sebenarnya dari penelitian asli berkaitan dengan berapa banyak untuk bertaruh berdasarkan sinyal yang berisik. Dalam kasus khusus, berapa banyak untuk bertaruh pada sinyal elektronik yang berisik di mana itu menunjukkan peluncuran senjata nuklir oleh Uni Soviet. Ada beberapa peluncuran dekat oleh Amerika Serikat dan Rusia, jelas salah. Berapa banyak Anda bertaruh pada sinyal?

Saya menyukai jawaban yang diberikan oleh Dave harris. meskipun saya akan datang pada masalah dari perspektif "risiko rendah", daripada memaksimalkan keuntungan

Jalan acak yang Anda lakukan, dengan asumsi taruhan fraksi Anda adalah $q$ dan probabilitas menang $p=0.5$ telah diberikan sebagai

$$Y_t|Y_{t-1}=(1-q+3qX_t)Y_{t-1}$$ mana $X_t\sim Bernoulli(p)$ . rata-rata Anda memiliki $$E(Y_t|Y_{t-1}) = (1-q+3pq)Y_{t-1}$$ Anda dapat menerapkan ini berulang untuk mendapatkan $$Y_t|Y_0=Y_0\prod_{j=1}^t (1-q+3qX_t)$$ dengan nilai yang diharapkan $$E(Y_t|Y_{0}) = (1-q+3pq)^t Y_{0}$$ Anda juga dapat menyatakan jumlah pada waktu$t$ sebagai fungsi dari variabel acak tunggal$Z_t=\sum_{j=1}^t X_t\sim Binomial(t,p)$ , tetapi mencatat bahwa$Z_t$ tidak independen dari$Z_{t-1}$ $$Y_t|Y_0=Y_0 (1+2q)^{Z_t}(1-q)^{t-Z_t}$$

strategi yang mungkin

Anda bisa menggunakan rumus ini untuk menentukan nilai "risiko rendah" untuk $q$ . Katakanlah dengan asumsi Anda ingin memastikan bahwa setelah $k$ kerugian berturut-turut Anda masih memiliki setengah dari kekayaan awal Anda. Kemudian Anda mengatur $q=1-2^{-k^{-1}}$

Mengambil contoh $k=5$ berarti kita menetapkan $q=0.129$ , atau dengan $k=15$ kita menetapkan $q=0.045$ .

Juga, karena strategi strategi bersifat rekursif, risiko ini adalah apa yang Anda ambil setiap taruhan. Yaitu, pada saat $s$ , dengan terus bermain Anda memastikan bahwa pada waktu $k+s$ kekayaan Anda akan setidaknya $0.5Y_{s}$

diskusi

strategi di atas tidak tergantung pada hasil dari kemenangan, tetapi lebih pada menetapkan batas pada kekalahan. Kita bisa mendapatkan kemenangan yang diharapkan dengan mengganti nilai untuk $q$ kita hitung, dan pada saat itu $k$ yang digunakan dengan mempertimbangkan risiko.

Namun, menarik untuk melihat median daripada yang diharapkan melunasi pada waktu $t$ , yang dapat ditemukan dengan mengasumsikan $median(Z_t)\approx tp$ .

$$Y_k|Y_0=Y_0 (1+2q)^{tp}(1-q)^{t(1-p)}$$ ketika $p=0.5$ kita memiliki rasio sama dengan $(1+q-2q^2)^{0.5t}$ . Ini dimaksimalkan ketika$q=0.25$ dan lebih besar dari$1$ ketika$q<0.5$

itu juga menarik untuk menghitung peluang Anda akan maju pada waktu $t$ . untuk melakukan ini kita perlu menentukan nilai $z$ sedemikian sehingga

$$(1+2q)^{z}(1-q)^{t-z}>1$$ melakukan penataan ulang kita menemukan bahwa proporsi kemenangan harus memenuhi $$\frac{z}{t}>\frac{\log(1-q)}{\log(1-q)-\log(1+2q)}$$ Ini dapat dicolokkan ke perkiraan normal (catatan: rata-rata$0.5$dan standar kesalahan$\frac{0.5}{\sqrt{t}}$ ) sebagai $$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)$$

yang jelas menunjukkan permainan memiliki peluang yang sangat bagus. faktor yang mengalikan $\sqrt{t}$ diminimalkan ketika$q=0$(nilai maksimal$\frac{1}{3}$ ) dan menurun secara monoton sebagai fungsi dari$q$. jadi strategi "risiko rendah" adalah bertaruh sebagian kecil dari kekayaanmu, dan bermain banyak kali.

misalkan kita membandingkan ini dengan $q=\frac{1}{3}$ dan$q=\frac{1}{100}$ . faktor untuk setiap kasus adalah$0.11$dan$0.32$. Ini berarti setelah$38$pertandingan, Anda akan memiliki sekitar 95% peluang untuk unggul dengan taruhan kecil, dibandingkan dengan peluang 75% dengan taruhan lebih besar. Selain itu, Anda juga memiliki peluang bangkrut dengan taruhan yang lebih besar, dengan asumsi Anda harus membulatkan taruhan Anda ke 5 sen atau dolar terdekat. Dimulai dengan$20$ini bisa$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$. This is a sequence of $14$ losses out of $38$, and given the game would expect $19$ losses, if you get unlucky with the first few bets, then even winning may not make up for a bad streak (e.g., if most of your wins occur once most of the wealth is gone). going broke with the smaller 1% stake is not possible in $38$ games. The flip side is that the smaller stake will result in a much smaller profit on average, something like a $350$ fold increase with the large bet compared to $1.2$ increase with the small bet (i.e. you expect to have 24 dollars after 38 rounds with the small bet and 7000 dollars with the large bet).

I don't think this is much different from the Martingale. In your case, there are no doubling bets, but the winning payout is 3x.

I coded a "living replica" of your tree. I run 10 simulations. In each simulation (trace), you start with 200 coins and try with the tree, 1 coin each time for 20,000 times.

The only conditions that stop the simulation are bankruptcy or having "survived" 20k attempts

I think that whatever the odds, sooner or later bankruptcy awaits you.

---

The code is improvised javascript but dependency-free: https://repl.it/@cilofrapez/MagicTree-Roulette

It shows you the results straight away. The code is simple to tweak: to run however many simulations, bet amount, however many attempts... Feel free to play!

At the bottom of the code, each simulation's (by default 10) results are saved into a CSV file with two columns: spin number and money. I made that so it could be fed it to an online plotter for the graphs.

It'd be effortless to have it all automated locally using the Google Charts library for example. If you only want to see the results on the screen, you can comment that last part out as I mentioned in the file.

EDIT

Source code:

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

Problem statement

Let $Y_t = \log_{10}(M_t)$ be the logarithm of the amount of money $M_t$ the gambler has at time $t$.

Let $q$ be the fraction of money that the gambler is betting.

Let $Y_0 = 1$ be the amount of money that the gambler starts with (ten dollars). Let $Y_L=-2$ be the amount of money where the gambler goes bankrupt (below 1 cent). For simplicity we add a rule that the gambler stops gambling when he has passed some amount of money $Y_W$ (we can later lift this rule by taking the limit $Y_W \to \infty$).

Random walk

You can see the growth and decline of the money as an asymmetric random walk. That is you can describe $Y_t$ as:

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

where

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

Probability of bankruptcy

Martingale

The expression

$$Z_t = c^{Y_t}$$

is a martingale when we choose $c$ such that.

$$c^{a_w}+ c^{a_l} = 2$$ (where $c<1$ if $q<0.5$). Since in that case

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

Probability to end up bankrupt

The stopping time (losing/bankruptcy $Y_t < Y_L$ or winning $Y_t>Y_W$) is almost surely finite since it requires in the worst case a winning streak (or losing streak) of a certain finite length, $\frac{Y_W-Y_L}{a_w}$, which is almost surely gonna happen.

Then, we can use the optional stopping theorem to say $E[Z_\tau]$ at the stopping time $\tau$ equals the expected value $E[Z_0]$ at time zero.

Thus

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

and

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

}