Pensei nesse problema no chuveiro, inspirado em estratégias de investimento.

Digamos que havia uma árvore mágica do dinheiro. Todos os dias, você pode oferecer uma quantia em dinheiro à árvore do dinheiro e ela triplicará ou a destruirá com probabilidade 50/50. Você percebe imediatamente que, em média, você ganhará dinheiro fazendo isso e está ansioso para tirar proveito da árvore do dinheiro. No entanto, se você oferecesse todo o seu dinheiro de uma só vez, teria 50% de perda de todo o seu dinheiro. Inaceitável! Você é uma pessoa bastante avessa a riscos e decide criar uma estratégia. Você quer minimizar as chances de perder tudo, mas também quer ganhar o máximo de dinheiro possível! Você cria o seguinte: todos os dias, você oferece 20% de seu capital atual à árvore do dinheiro. Supondo que o valor mais baixo que você pode oferecer seja de 1 centavo, seria necessário um período de 31 perdas para perder todo o seu dinheiro se você começasse com 10 dólares. O que mais, quanto mais dinheiro você ganhar, mais longa será a sequência de derrotas para você perder tudo, incrível! Você começa rapidamente a ganhar muito dinheiro. Mas então surge uma idéia: você pode oferecer 30% a cada dia e ganhar muito mais dinheiro! Mas espere, por que não oferecer 35%? 50%? Um dia, com grandes cifrões nos olhos, você corre para a árvore do dinheiro com todos os seus milhões e oferece 100% do seu dinheiro, que a árvore do dinheiro queima prontamente. No dia seguinte, você consegue um emprego no McDonalds. que a árvore do dinheiro queima imediatamente. No dia seguinte, você consegue um emprego no McDonalds. que a árvore do dinheiro queima imediatamente. No dia seguinte, você consegue um emprego no McDonalds.

Existe uma porcentagem ideal do seu dinheiro que você pode oferecer sem perder tudo?

(sub) perguntas:

Se houver uma porcentagem ideal que você deve oferecer, isso é estático (ou seja, 20% todos os dias) ou a porcentagem deve aumentar à medida que seu capital aumenta?

Ao oferecer 20% todos os dias, as chances de perder todo o seu dinheiro diminuem ou aumentam com o tempo? Existe uma porcentagem de dinheiro de onde as chances de perder todo o seu dinheiro aumentam com o tempo?

Este é um problema bem conhecido. Isso é chamado de aposta de Kelly. A resposta, a propósito, é 1/3. É equivalente a maximizar a utilidade logarítmica da riqueza.

Kelly começou levando tempo para o infinito e depois resolvendo para trás. Como você sempre pode expressar retornos em termos de composição contínua, também pode reverter o processo e expressá-lo em logs. Vou usar a explicação do utilitário de log, mas o utilitário de log é uma conveniência. Se você estiver maximizando a riqueza como , você terminará com uma função que funciona da mesma forma que o utilitário de log. Se for a probabilidade de pagamento for a probabilidade de ganhar e for a porcentagem da riqueza investida, a derivação a seguir funcionará.$n\to\infty$$b$$p$$X$

Para uma aposta binária, , por um único período e riqueza unitária.$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}$$

Definir a derivada como zero para encontrar os extremos,

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

Multiplicação cruzada, você acaba com

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

No seu caso,

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

Você pode facilmente expandir isso para resultados múltiplos ou contínuos, resolvendo a utilidade esperada da riqueza sobre uma distribuição de probabilidade conjunta, escolhendo as alocações e sujeita a quaisquer restrições. Curiosamente, se você executá-lo dessa maneira, incluindo restrições, como a capacidade de atender aos pagamentos de hipotecas e assim por diante, você contabilizou seu conjunto total de riscos e possui um ajuste de risco ou pelo menos um controle controlado solução.

Desiderata O objetivo real da pesquisa original tinha a ver com o quanto jogar com base em um sinal barulhento. No caso específico, quanto apostar em um sinal eletrônico barulhento, onde indica o lançamento de armas nucleares pela União Soviética. Houve vários lançamentos perto dos Estados Unidos e da Rússia, obviamente errados. Quanto você joga em um sinal?

Gostei da resposta dada por Dave Harris. embora eu achasse o problema de uma perspectiva de "baixo risco", em vez de maximizar o lucro

O passeio aleatório que você está fazendo, assumindo que sua fração aposta é e a probabilidade de ganhar foi dada como que . em média, você possui Você pode aplicar isso iterativamente para obter com valor esperado você também pode expressar a quantidade no tempo em função de uma única variável aleatória , mas observando que não é independente de$q$$p=0.5$

$$Y_t|Y_{t-1}=(1-q+3qX_t)Y_{t-1}$$ X t ~ B e r n o u l l i ( p ) E ( Y t | Y t - 1 ) = ( 1 - q + 3 p q )Y t - 1 Y t | Y 0 = Y 0 t ∏ j = 1 i n$X_t\sim Bernoulli(p)$ $$E(Y_t|Y_{t-1}) = (1-q+3pq)Y_{t-1}$$ $$Y_t|Y_0=Y_0\prod_{j=1}^t (1-q+3qX_t)$$ $$E(Y_t|Y_{0}) = (1-q+3pq)^t Y_{0}$$ $t$$Z_t=\sum_{j=1}^t X_t\sim Binomial(t,p)$$Z_t$$Z_{t-1}$ $$Y_t|Y_0=Y_0 (1+2q)^{Z_t}(1-q)^{t-Z_t}$$

estratégia possível

você pode usar esta fórmula para determinar um valor de "baixo risco" para . Digamos que você queira garantir que, após perdas consecutivas, você ainda tenha metade da sua riqueza original. Então você define$q$$k$$q=1-2^{-k^{-1}}$

Tomando o exemplo significa que definimos , ou com , definimos .$k=5$$q=0.129$$k=15$$q=0.045$

Além disso, devido à natureza recursiva da estratégia, esse risco é o que você está assumindo a cada aposta. Ou seja, no tempo , continuando a jogar, você garante que no momento sua riqueza será de pelo menos$s$$k+s$$0.5Y_{s}$

discussão

a estratégia acima não depende do resultado da vitória, mas de estabelecer um limite para a perda. Podemos obter os ganhos esperados substituindo o valor calculado e no momento usado com o risco em mente.$q$$k$

no entanto, é interessante observar a recompensa média em vez do esperado no tempo , que pode ser encontrado assumindo a . quando , temos a razão igual a . Isso é maximizado quando e maior que quando$t$$median(Z_t)\approx tp$

$$Y_k|Y_0=Y_0 (1+2q)^{tp}(1-q)^{t(1-p)}$$ $p=0.5$$(1+q-2q^2)^{0.5t}$$q=0.25$$1$$q<0.5$

também é interessante calcular a chance de você estar à frente no tempo . para fazer isso, precisamos determinar o valor tal que fazendo alguma reorganização, descobrimos que a proporção de vitórias deve satisfazer Isso pode ser conectado a uma aproximação normal (nota: média de e erro padrão de ) como $t$$z$

$$(1+2q)^{z}(1-q)^{t-z}>1$$ $$\frac{z}{t}>\frac{\log(1-q)}{\log(1-q)-\log(1+2q)}$$ $0.5$$\frac{0.5}{\sqrt{t}}$ $$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)$$

o que mostra claramente que o jogo tem chances muito boas. o fator que multiplica é minimizado quando (valor maximizado de ) e está diminuindo monotonicamente em função de . portanto, a estratégia de "baixo risco" é apostar uma fração muito pequena da sua riqueza e jogar várias vezes.$\sqrt{t}$$q=0$$\frac{1}{3}$$q$

suponha que comparemos isso com e . o fator para cada caso é e . Isso significa que, após jogos, você teria cerca de 95% de chance de estar à frente com a aposta pequena, em comparação com 75% de chance com a aposta maior. Além disso, você também tem a chance de falir com a aposta maior, supondo que você precise arredondar sua aposta para os 5 centavos ou dólar mais próximos. Começando com isso poderia ir . Esta é uma sequência de derrotas em , e dado o jogo esperaria$q=\frac{1}{3}$$q=\frac{1}{100}$$0.11$$0.32$$38$$20$$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$$14$$38$$19$perdas, se você tiver azar com as primeiras apostas, mesmo as vitórias podem não compensar uma sequência ruim (por exemplo, se a maioria de suas vitórias ocorrer depois que a maior parte da riqueza se for). quebrar com a menor participação de 1% não é possível em jogos. O outro lado é que a aposta menor resultará em um lucro muito menor, em média, algo como um aumento de vezes com a aposta grande em comparação com o aumento de com a aposta pequena (ou seja, você espera ter 24 dólares depois de 38 rodadas com a pequena aposta e 7000 dólares com a aposta grande).$38$$350$$1.2$

Não acho que isso seja muito diferente do Martingale. No seu caso, não há apostas dobradas, mas o pagamento vencedor é 3x.

Eu codifiquei uma "réplica viva" da sua árvore. Eu corro 10 simulações. Em cada simulação (rastreio), você começa com 200 moedas e tenta com a árvore, uma moeda por vez, 20.000 vezes.

As únicas condições que interrompem a simulação são a falência ou a "sobrevivência" de 20 mil tentativas

Penso que, sejam quais forem as probabilidades, mais cedo ou mais tarde a bancarrota espera por você.

---

O código é javascript improvisado, mas sem dependência: https://repl.it/@cilofrapez/MagicTree-Roulette

Ele mostra os resultados imediatamente. O código é simples de ajustar: executar quantas simulações, valor da aposta, quantas tentativas ... Sinta-se à vontade para jogar!

Na parte inferior do código, os resultados de cada simulação (por padrão 10) são salvos em um arquivo CSV com duas colunas: número da rotação e dinheiro. Fiz isso para que ele pudesse ser alimentado em uma plotadora on-line para os gráficos.

Seria fácil automatizar tudo localmente, por exemplo, usando a biblioteca do Google Charts. Se você quiser ver apenas os resultados na tela, pode comentar a última parte, como mencionei no arquivo.

EDITAR

Código fonte:

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

Declaração do problema

Seja o logaritmo da quantidade de dinheiro o jogador tem no tempo .$Y_t = \log_{10}(M_t)$$M_t$$t$

Seja a fração do dinheiro que o jogador está apostando.$q$

Seja a quantia em dinheiro que o jogador começa (dez dólares). Seja a quantia em dinheiro em que o jogador vai à falência (abaixo de 1 centavo). Por uma questão de simplicidade, adicionamos uma regra de que o jogador para de jogar quando passa uma quantia de dinheiro (mais tarde, podemos elevar essa regra assumindo o limite ).$Y_0 = 1$$Y_L=-2$$Y_W$$Y_W \to \infty$

Caminhada aleatória

Você pode ver o crescimento e o declínio do dinheiro como uma caminhada aleatória assimétrica. Ou seja, você pode descrever como:$Y_t$

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

Onde

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

Probabilidade de falência

Martingale

A expressão

$$Z_t = c^{Y_t}$$

é um martingale quando escolhemos tal que.$c$

$$c^{a_w}+ c^{a_l} = 2$$ (onde se ). Uma vez que nesse caso$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]$$

Probabilidade de falência

O tempo de parada (perda / falência ou vitória ) é quase certamente finito, pois exige, no pior caso, uma sequência de vitórias (ou sequência de derrotas) de um determinado comprimento finito, , o que quase certamente vai acontecer.$Y_t < Y_L$$Y_t>Y_W$$\frac{Y_W-Y_L}{a_w}$

Então, podemos usar o teorema da parada opcional para dizer no tempo de parada igual ao valor esperado no tempo zero.$E[Z_\tau]$$\tau$$E[Z_0]$

portanto

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

e

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

e o limite$Y_W \to \infty$

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

Conclusões

Existe uma porcentagem ideal do seu dinheiro que você pode oferecer sem perder tudo?

Qualquer que seja a porcentagem ideal, dependerá de como você avalia lucros diferentes. No entanto, podemos dizer algo sobre a probabilidade de perder tudo.

Somente quando o jogador apostar zero fração do seu dinheiro, ele certamente não irá à falência.

Com o aumento de a probabilidade de falir aumentará até certo ponto em que o jogador quase certamente falirá dentro de um tempo finito (a ruína do jogador mencionada por Robert Long nos comentários). Este ponto, , está em Este é o ponto em que não há solução para abaixo de um. Este também é o ponto em que as etapas crescentes são menores que as etapas decrescentes .$q$$q_{\text{gambler's ruin}}$

$$q_{\text{gambler's ruin}} = 1-1/b$$ $c$$a_w$$a_l$

Assim, para , desde que o jogador aposte menos da metade do dinheiro, o jogador certamente não irá à falência.$b=2$

as chances de perder todo o seu dinheiro diminuem ou aumentam com o tempo?

A probabilidade de falir depende da distância da quantidade de dinheiro em que o jogador vai à falência. Quando o dinheiro do jogador aumentará, em média, e a probabilidade de falir diminuirá, em média.$q<q_{\text{gambler's ruin}}$

Probabilidade de falência ao usar o critério de Kelly.

Quando você usa o critério de Kelly mencionado na resposta de Dave Harris, , para ser a razão entre perda e lucro em uma única aposta, então independente de o valor de será igual a e a probabilidade de falir será de .$q = 0.5(1-1/b)$$b$$b$$c$$0.1$$0.1^{S-L}$

Ou seja, independente do parâmetro de assimetria da árvore mágica, a probabilidade de falência, ao usar o critério Kelly, é igual à razão entre a quantidade de dinheiro em que o jogador vai à falência e a quantidade de dinheiro que o jogador inicia com. Por dez dólares e 1 centavo, é uma probabilidade de 1: 1000 de falência ao usar o critério de Kelly.$b$

Simulações

As simulações abaixo mostram diferentes trajetórias simuladas para diferentes estratégias de jogo. As trajetórias vermelhas são aquelas que acabaram em falência (acerte a linha ).$Y_t=-2$

Distribuição dos lucros após o tempo$t$

Para ilustrar ainda mais os possíveis resultados do jogo com a árvore do dinheiro, você pode modelar a distribuição de como um processo de difusão unidimensional em um campo de força homogêneo e com um limite absorvente (onde o jogador fica à falência). A solução para esta situação foi dada por Smoluchowski$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. (disponível on-line em: https://www.physik.uni-augsburg.de/theo1/hanggi/History/BM-History.html )

Equação 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]$$

Essa equação de difusão refere-se ao problema da árvore quando definimos a velocidade igual ao aumento esperado , definimos igual à variação da alteração em uma única etapa , é o quantidade inicial de dinheiro, e é o número de etapas.$c$$E[Y_t]$$D$$\text{Var}(X_t)$$x_0$$t$

A imagem e o código abaixo demonstram a equação:

• O histograma mostra o resultado de uma simulação.

• A linha pontilhada mostra um modelo quando usamos uma distribuição normal ingênua para aproximar a distribuição (isso corresponde à ausência da barreira absorvente da "falência"). Isso está errado porque alguns dos resultados acima do nível de falência envolvem trajetórias que passaram no nível de falência mais cedo.

• A linha contínua é a aproximação usando a fórmula de Smoluchowski.

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

}