जादू पैसे के पेड़ की समस्या


19

मैंने शॉवर में इस समस्या के बारे में सोचा, यह निवेश रणनीतियों से प्रेरित था।

मान लीजिए कि एक जादू का पेड़ था। हर दिन, आप पैसे के पेड़ को राशि की पेशकश कर सकते हैं और यह या तो इसे तीन गुना कर देगा, या इसे 50/50 संभावना के साथ नष्ट कर देगा। आप तुरंत नोटिस करते हैं कि औसत रूप से आप ऐसा करके पैसा प्राप्त करेंगे और पैसे के पेड़ का लाभ उठाने के लिए उत्सुक हैं। हालाँकि, यदि आपने अपना सारा पैसा एक ही बार में दे दिया, तो आपके पास अपना सारा पैसा खोने का 50% होगा। गवारा नहीं! आप बहुत जोखिम वाले व्यक्ति हैं, इसलिए आप एक रणनीति के साथ आने का फैसला करते हैं। आप सब कुछ खोने की बाधाओं को कम करना चाहते हैं, लेकिन आप भी उतना पैसा कमाना चाहते हैं! आप निम्नलिखित के साथ आते हैं: हर दिन, आप अपनी वर्तमान पूंजी का 20% पैसा पेड़ को देते हैं। यदि आप सबसे कम 1 प्रतिशत की पेशकश कर सकते हैं, तो यह मान लें कि यदि आप 10 डॉलर के साथ शुरू करते हैं, तो आपके सभी पैसे खोने के लिए 31 नुकसान होगा। इससे ज्यादा और क्या, जितनी अधिक नकदी आप कमाते हैं, उतनी ही लंबी लकीर आपके लिए सब कुछ खोने के लिए अद्भुत होने की आवश्यकता है! आप जल्दी से नकदी का भार अर्जित करना शुरू करते हैं। लेकिन फिर एक विचार आपके दिमाग में आता है: आप हर दिन 30% की पेशकश कर सकते हैं और अधिक पैसा कमा सकते हैं! लेकिन रुकिए, 35% की पेशकश क्यों नहीं? 50%? एक दिन, आपकी आंखों में बड़े डॉलर के संकेत के साथ आप अपने सभी लाखों लोगों के साथ पैसे के पेड़ तक पहुंचते हैं और अपनी 100% नकदी की पेशकश करते हैं, जो पैसे का पेड़ तुरंत जलता है। अगले दिन आपको मैकडॉनल्ड्स में नौकरी मिल जाती है। जो मनी ट्री तुरंत जलता है। अगले दिन आपको मैकडॉनल्ड्स में नौकरी मिल जाती है। जो मनी ट्री तुरंत जलता है। अगले दिन आपको मैकडॉनल्ड्स में नौकरी मिल जाती है।

क्या आपकी नकदी का एक इष्टतम प्रतिशत है जो आप इसे खोए बिना दे सकते हैं?

(उप) प्रश्न:

यदि कोई इष्टतम प्रतिशत है जिसे आपको पेश करना चाहिए, तो क्या यह स्थिर (यानी हर दिन 20%) है या आपकी पूंजी बढ़ने पर प्रतिशत बढ़ना चाहिए?

हर दिन 20% की पेशकश करके, अपने सभी पैसे खोने की संभावना कम हो जाती है या समय के साथ बढ़ती है? क्या समय के साथ-साथ आपके सभी पैसे खोने की संभावनाएं कम हो जाती हैं?


7
यह जुआरी की बर्बादी पर एक बदलाव की तरह लगता है
रॉबर्ट लॉन्ग

2
इस प्रश्न का बहुत कुछ इस बात पर निर्भर करता है कि क्या भिन्नात्मक सेंट संभव हैं। इसके अतिरिक्त, कई संभावित लक्ष्य हैं जो किसी को इस स्थिति में हो सकते हैं। विभिन्न लक्ष्यों में अलग-अलग इष्टतम रणनीतियाँ होंगी।
बुज

जवाबों:


19

यह एक जानी-मानी समस्या है। इसे केली बेट कहा जाता है। उत्तर, वैसे, 1 / 3rd है। यह धन की लॉग उपयोगिता को अधिकतम करने के बराबर है।

केली ने अनन्तता के लिए समय निकालना शुरू किया और फिर पिछड़ेपन को हल किया। चूंकि आप निरंतर कंपाउंडिंग के संदर्भ में हमेशा रिटर्न व्यक्त कर सकते हैं, तो आप प्रक्रिया को उल्टा भी कर सकते हैं और लॉग में व्यक्त कर सकते हैं। मैं लॉग उपयोगिता विवरण का उपयोग करने जा रहा हूं, लेकिन लॉग उपयोगिता एक सुविधा है। आप के रूप में धन को अधिकतम रहे हैं, तो n तो आप एक समारोह है कि बाहर काम करता है लॉग उपयोगिता के रूप में ही साथ खत्म हो जाएगा। यदि b पेआउट ऑड्स है, और p जीतने की संभावना है, और X निवेशित धन का प्रतिशत है, तो निम्नलिखित व्युत्पत्ति काम करेगी।

एक द्विआधारी शर्त के लिए, E(log(X))=plog(1+bX)+(1p)log(1X) , एक अवधि और इकाई धन के लिए।

ddXE[log(x)]=ddX[plog(1+bX)+(1p)log(1X)]
=pb1+bX1p1X

एक्स्ट्रेमा को खोजने के लिए व्युत्पन्न को शून्य पर सेट करना,

pb1+bX1p1X=0

क्रॉस गुणा करना, आप

pb(1X)(1p)(1+bX)=0
pbpbX1bX+p+pbX=0
bX=pb1+p
साथ समाप्त होते हैं p b - 1 + p
X=bp(1p)b

आपके मामले में,

X=3×12(112)3=13.

आप एक संयुक्त संभाव्यता वितरण पर धन की अपेक्षित उपयोगिता को हल करके, आवंटन और किसी भी बाधाओं के अधीन चुनकर कई या निरंतर परिणामों के लिए आसानी से इसका विस्तार कर सकते हैं। दिलचस्प बात यह है कि अगर आप इसे इस तरीके से करते हैं, जैसे कि बाधाओं से, जैसे कि बंधक भुगतान और उसके बाद मिलने की क्षमता, तो आपने अपने कुल जोखिमों का हिसाब लगाया है और इसलिए आपके पास जोखिम-समायोजित या कम से कम जोखिम-नियंत्रित है समाधान।

Desiderata मूल अनुसंधान का वास्तविक उद्देश्य शोर संकेत के आधार पर कितना जुआ करना था। विशिष्ट मामले में, शोर इलेक्ट्रॉनिक सिग्नल पर कितना जुआ खेलने के लिए जहां यह सोवियत संघ द्वारा परमाणु हथियारों के लॉन्च का संकेत था। संयुक्त राज्य अमेरिका और रूस दोनों के पास कई लॉन्च हुए हैं, जाहिर है कि गलती से। आप एक सिग्नल पर कितना जुआ खेलते हैं?


इस रणनीति के लिए जा रहा के एक उच्च जोखिम देना होगा तोड़ दिया मैं कम अंशों की तुलना में लगता है
probabilityislogic

@probabilityislogic केवल उस मामले में जहां पेनी मौजूद हैं। असतत मामले में, यह सच हो जाएगा क्योंकि आप अपने अंतिम पैसे को दांव पर लगा सकते हैं। आप एक पैसे का तीसरा हिस्सा नहीं दे सकते। एक असतत दुनिया में, यह आंतरिक रूप से सच है कि दिवालियापन की संभावना आबंटन के आकार में बढ़ रही है, जो भुगतान के मामले से स्वतंत्र है। असतत दुनिया में 2% आवंटन में 1% से अधिक दिवालियापन की संभावना है।
डेव हैरिस

@probabilityislogic यदि आप 3 सेंट से शुरू करते हैं तो यह जोखिम भरा है। यदि आप $ 550 से शुरू करते हैं तो दिवालिया होने के 1024 में एक मौका कम है। उचित पॉट आकारों के लिए, असतत पतन का जोखिम तब तक छोटा हो जाता है जब तक कि आप वास्तव में अनंत तक नहीं जाते हैं, तब तक यह एक निश्चितता बन जाती है जब तक कि उधार लेने की अनुमति न हो।
डेव हैरिस

मुझे उम्मीद थी कि यह एक ज्ञात समस्या होगी लेकिन मुझे इस बात का कोई सुराग नहीं था कि इसे कैसे देखा जाए। केली के उल्लेख के लिए धन्यवाद। एक सवाल हालांकि: केली मानदंड पर विकिपीडिया इष्टतम प्रतिशत की गणना करने के लिए निम्न सूत्र का उल्लेख करता है: (बीपी-क्यू) / बी। जहाँ b वह # डॉलर्स है जो आपको 1 $ सट्टे में मिलता है, जीतने की संभावना p और हारने का मौका q। यदि मैं इसे अपने परिदृश्य के लिए भरता हूं तो मुझे यह मिलता है: (2 * 0.5-0.5) / 2=0.25। मतलब सट्टेबाजी का इष्टतम प्रतिशत 25% होगा। 1 / 3rd के आपके उत्तर से इस विसंगति का क्या कारण है?
ElectronicToothpick

3
@ElectronicToothpick यदि आप b = 3 भरते हैं तो आपको 1/3 मिलता है। अंतर यह है कि आप तीन बार भुगतान कैसे मानते हैं। कहते हैं कि आप 1 डॉलर के साथ शुरू करते हैं और आप 50 सेंट की शर्त लगाते हैं, तो आप ट्रिपल पेआउट को पचास-पचास 50 सेंट या 2 डॉलर (b = 2, यानी माइनस 50 सेंट या प्लस 2 गुना 50 सेंट) बनाम पचास-पचास के साथ समाप्त मानते हैं। 50 सेंट या 2.50 डॉलर (बी = 3, यानी माइनस 50 सेंट या 3 गुना 50 सेंट)।
सेक्सटस एम्पिरिकस

5

मुझे डेव हैरिस द्वारा दिया गया जवाब पसंद आया। हालांकि मैं लाभ को कम करने के बजाय "कम जोखिम" के दृष्टिकोण से समस्या पर आऊंगा

यादृच्छिक की पैदल दूरी पर आप कर रहे हैं, अपने अंश शर्त यह सोचते है q और जीतने की संभावना p=0.5 है के रूप में दिया जाता है

Yt|Yt1=(1q+3qXt)Yt1
जहां XtBernoulli(p) । औसतन आपके पास
E(Yt|Yt1)=(1q+3pq)Yt1
आप iteratively इस आवेदन कर सकते हैं पाने के लिए
Yt|Y0=Y0j=1t(1q+3qXt)
की उम्मीद मूल्य के साथ
E(Yt|Y0)=(1q+3pq)tY0
आप भी समय में राशि व्यक्त कर सकते हैंt एक भी यादृच्छिक चर के एक समारोह के रूपZt=j=1tXtBinomial(t,p) , लेकिन यह देखते हुए किZt ,Zt1 Y t से स्वतंत्र नहीं है | Y 0 = Y 0 ( 1)
Yt|Y0=Y0(1+2q)Zt(1q)tZt

संभव रणनीति

आप q लिए "कम जोखिम" मूल्य निर्धारित करने के लिए इस सूत्र का उपयोग कर सकते हैं । यह मानते हुए कि आप यह सुनिश्चित करें कि के बाद चाहते थे कहो k लगातार घाटे आप अभी भी आधे अपने मूल धन था। फिर आपने q=12k1

उदाहरण के k=5 अर्थ है कि हमने q=0.129 सेट किया है , या k=15 हमने q=0.045 निर्धारित किया है ।

इसके अलावा, रणनीति की पुनरावर्ती प्रकृति के कारण, यह जोखिम वही है जो आप हर एक दांव पर ले रहे हैं। उस समय, है s , आप खेलने के लिए जारी रखते हुए यह सुनिश्चित कर रहे हैं उस समय k+s अपने धन हो जाएगा कम से कम 0.5Ys

विचार-विमर्श

उपरोक्त रणनीति जीत से भुगतान पर निर्भर नहीं है, बल्कि हारने पर सीमा निर्धारित करने के बारे में है। हम गणना की गई q लिए मूल्य में प्रतिस्थापित करके अपेक्षित जीत प्राप्त कर सकते हैं , और उस समय k में जिसका उपयोग जोखिम के साथ किया गया था।

तथापि, यह मंझला के बजाय बंद समय में उम्मीद भुगतान को देखने के लिए दिलचस्प है t , यह मानते हुए से पाया जा सकता है median(Zt)tp

Yk|Y0=Y0(1+2q)tp(1q)t(1p)
जब p=0.5 , तो हमारा अनुपात समान होता है (1+q2q2)0.5t । यह तब अधिकतम हो जाता है जबq=0.25 और1 से अधिक होजबq<0.5

यह उस समय की गणना के लिए भी दिलचस्प है जब आप समय t पर आगे होंगे । ऐसा करने के लिए हमें मान z निर्धारित करने की आवश्यकता है जैसे कि

(1+2q)z(1q)tz>1
कुछ पुनर्व्यवस्थित करते हुए हम पाते हैं कि जीत के अनुपात को z को संतुष्ट करना चाहिए।
zt>log(1q)log(1q)log(1+2q)
This can be plugged into a normal approximation (note: mean of 0.5 and standard error of 0.5t
Pr(ahead at time t)Φ(tlog(1+2q)+log(1q)[log(1+2q)log(1q)])

tq=013q. so the "low risk" strategy is to bet a very small fraction of your wealth, and play a large number of times.

q=13q=11000.110.32. This means after 38 games you would have around a 95% chance to be ahead with the small bet, compared to a 75% chance with the larger bet. Additionally, you also have a chance of going broke with the larger bet, assuming you had to round your stake to the nearest 5 cents or dollar. Starting with 20 this could go 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).


it is if you consider that q is chosen in a low risk manner and we aren't calculating it for t>>k, this isn't too bad an approximation. So it is probably overstating the profit from the large betting strategy.
probabilityislogic

Your approach to maximize the median of Zt is actually the same as the approach from Dave Harris which is maximizing the mean of Zt (which is the same as the median of Zt). It would be different when one is maximizing the mean of Yt which is lognormal distributed and for which the mean and median are not the same.
Sextus Empiricus

5

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

enter image description here

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

1
Are you able to post the code that you wrote for this as well please?
baxx

1
This is betting with a constant stake - but betting a fixed proportion of your wealth, such as 14 here, each time would produce a different result. You may need to adapt this to avoid fractional coins (e.g. round down unless this produces a value less than 1 coin, in which cases bet 1 coin)
Henry

@baxx Sure, I just updated the post. Henry, I'm not sure I understood you. I can adapt the code to fit different needs if you want.
Carles Alcolea

@CarlesAlcolea I was just saying that it would be nice if the code you used for the post was contained within the post itself. I'm not sure if the link to repl you've posted will die at some point or not
baxx

1
@baxx Sure! After writing this improvised program, I thought I should make a small online app, to be able to explore almost any situation of this kind easily. I didn't find any. Now I'm drowned in work so for the moment I leave the code in the post and the app on my to-do list
Carles Alcolea

4

Problem statement

Let Yt=log10(Mt) be the logarithm of the amount of money Mt the gambler has at time t.

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

Let Y0=1 be the amount of money that the gambler starts with (ten dollars). Let YL=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 YW (we can later lift this rule by taking the limit YW).

Random walk

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

Yt=Y0+i=1tXi

where

P[Xi=aw=log(1+2q)]=P[Xi=al=log(1q)]=12

Probability of bankruptcy

Martingale

The expression

Zt=cYt

is a martingale when we choose c such that.

caw+cal=2
(where c<1 if q<0.5). Since in that case

E[Zt+1]=E[Zt]12caw+E[Zt]12cal=E[Zt]

Probability to end up bankrupt

The stopping time (losing/bankruptcy Yt<YL or winning Yt>YW) is almost surely finite since it requires in the worst case a winning streak (or losing streak) of a certain finite length, YWYLaw, which is almost surely gonna happen.

Then, we can use the optional stopping theorem to say E[Zτ] at the stopping time τ equals the expected value E[Z0] at time zero.

Thus

cY0=E[Z0]=E[Zτ]P[Yτ<L]cYL+(1P[Yτ<L])cYW

and

P[Yτ<YL]cY0cYWcYLcYW

and the limit YW

P[Yτ<YL]cY0YL

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, qgambler's ruin, is at

qgambler's ruin=11/b
This is the point where there is no solution for c below one. This is also the point where the increasing steps aw are smaller than the decreasing steps al.

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<qgambler'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(11/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.1SL.

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 Yt=2).

simulations

Distribution of profits after time t

To further illustrate the possible outcomes of gambling with the money tree, you can model the distribution of Yt 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(x0,x,t)=ec(xx0)2Dc2t4D2πDt[e(xx0)24Dte(x+x0)24Dt]

This diffusion equation relates to the tree problem when we set the speed c equal to the expected increase E[Yt], we set D equal to the variance of the change in a single steps Var(Xt), x0 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.

illustration as diffusion in force field

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

}

"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" Im a bit surprised about this. So this means the probability to go bankrupt will be 1:1000 even if the payout is 10 times the offered money per round? How is this possible when the odds of going bankrupt decrease as your money grows?
ElectronicToothpick

1
@ElectronicToothpick If the payout is larger, and if you do not change the fraction that you gamble, then the probability to go bankrupt will be smaller. However, when you increase the fraction that you gamble, then this may not be true anymore. With the Kelly criterion, you will increase the fraction to gamble when the payout is higher. This will increase the expected value of the logarithm of the money, but as a consequence, the probability to go bankrupt will remain the same.
Sextus Empiricus

1
Actually, when the gambler is not using the Kelly criterion, which optimizes E[logMt], but instead chooses to optimize E[Mt], then the consequence is that a higher fraction of the amount of money is being gambled. Possibly this might lead to an increase in the risk of bankruptcy when the payout is made larger. I could add an analysis of this, but I am afraid that my answer is already too long and/or complex.
Sextus Empiricus
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.