Steven R. Dunbar
Department of Mathematics
203 Avery Hall
University of Nebraska-Lincoln
Lincoln, NE 68588-0130
http://www.math.unl.edu
Voice: 402-472-3731
Fax: 402-472-8466

__________________________________________________________________________

_______________________________________________________________________

Note: To read these pages properly, you will need the latest version of the Mozilla Firefox browser, with the STIX fonts installed. In a few sections, you will also need the latest Java plug-in, and JavaScript must be enabled. If you use a browser other than Firefox, you should be able to access the pages and run the applets. However, mathematical expressions will probably not display correctly. Firefox is currently the only browser that supports all of the open standards.

_______________________________________________________________________________________________

Rating

Everyone: contains no mathematics.

_______________________________________________________________________________________________

Section Starter Question

Suppose you start with a fortune of $10, and you want to gamble to achieve $20 before you go broke. Your gambling game is to flip a fair coin successively, and gain $1 if the coin comes up “Heads” and lose $1 if the coin comes up “Tails”. What do you estimate is the probability of achieving $20 before going broke? How long do you estimate it takes before one of the two outcomes occurs? How do you estimate each of these quantities?

_______________________________________________________________________________________________

Key Concepts

1. Performing an experiment to gain intuition about coin-tossing games.

__________________________________________________________________________

Vocabulary

1. We call victory the state of reaching a fortune goal before going broke.
2. We call ruin the state of going broke before reaching a fortune goal.

__________________________________________________________________________

Mathematical Ideas

Pure Risk Modeling

We need a better understanding of the paths that risky securities take. We shall make and investigate a greatly simplified model of randomness and risk. For our model, we assume:

1. Time is discrete, occurring at $t_0=0,t_1,t_2,\dots$.
2. There are no risk-free investments available, (i.e. no interest-bearing bonds).
3. There are no options, and no financial derivatives.
4. The only investments are risk-only, that is, our fortune at any time is a random variable:
   $$T_{n+1}=T_n+Y_{n+1}$$

   where $T_0$ is our given initial fortune, and for simplicity,

   $$Y_n=\left\{\begin{array}{c}+1\text{ probability }1∕2\hfill \\ -1\text{ probability }1∕2\hfill \end{array}\right.$$

Our model is commonly called “gambling” and we will investigate the probabilities of making a fortune by gambling.

Some Humor

An Experiment

1. Each “gambler” has a chart for recording the outcomes of each game (see below) and a sheet of graph paper.
2. Each “gambler” has a fair coin to flip, say a penny.
3. Each “gambler” flips the coin, and records a $+1$ (gains $1) if the coin comes up “Heads” and records $-1$ (loses $1) if the coin comes up “Tails”. On the chart, the player records the outcome of each flip with the flip number, the outcome as “H” or “T” and keeps track of the cumulative fortune of the gambler so far. Keep these records in a neat chart, since we will refer to them later.
4. Each “gambler” should record $100$ flips, which takes about 10 to 20 minutes.

Some Outcomes

A simulation with 30 “gamblers” obtained the following results:

1. 14 gamblers reached a net loss of $-10$ before reaching a net gain of $+10$, that is, achieved “victory”.
2. 9 gamblers reached a net gain of $+10$ before reaching a net loss of $-10$, that is, were “ruined”.
3. 7 gamblers still had not reached a net loss of $+10$ or $-10$ yet.

This closely matches the predicted outcomes of $1∕2$ the gamblers being victorious, not as close for the predicted outcome of $1∕2$ being ruined. The mean duration until vicotry or ruin was $41.6$.

Sources

This section is adapted from ideas in William Feller’s classic text, An Introduction to Probability Theory and Its Applications, Volume I, Third Edition.

The GeoGebra script is adapted from a demonstration and discussion among “carlosgomes” of Amarante, Portugal; Noel Lambert of Vosges, France; and Juan Vicente Snchez Gaitero of Cadiz, Spain on geogebra.org

____________________________________________________________

Algorithms, Scripts, Simulations

Algorithm

The probability of Heads is $p$. In matrix-oriented languages, use $k$ columns of the matrix for the iterations of an experiment each with $n$ trials. This is more efficient than using for-loops or the equivalent.

Then each $n\times 1$ column vector contains the outcomes of the experiment. Use the random number generator to create a random number in $\left(0,1\right)$. To simulate the flip of a coin use logical functions to score a 1, also counted as a Head, if the value is less than $p$; a 0 , also counted as a Tail if the value is greater than $p$. Column sums then give a $1\times k$ vector of total numbers of Heads. Statistical measures can then be applied to this vector. For wins and losses, linearly transform the coin flips to $1$ if Heads, a $-1$ if Tails. Cumulatively sum the entries to create the running total. Apply statistical measures to the last row of the totals.

Finally, set values for victory and ruin. Check when each column first hits victory or ruin.

Scripts

Geogebra

This is a Java Applet created using GeoGebra from www.geogebra.org - it looks like you don't have Java installed, please go to www.java.com

R

    p <$-$ 0.5 
    n <$-$ 15 
    k <$-$ 10 
    coinFlips <$-$ array( 0+(runif(n∗k) <= p), dim=c(n,k)) 
    # 0+ coerces Boolean to numeric 
    headsTotal <$-$ colSums(coinFlips) 
    muHeads <$-$ mean(headsTotal) 
    sigmaSquaredHeads <$-$ var(headsTotal) 
 
    winLose <$-$ 2∗coinFlips $-$ 1 
    totals <$-$ apply( winLose, 2, cumsum) 
      # the second argument ‘‘2’’ means column$-$wise 
    muWinLose <$-$ mean( totals[n,]) 
    sigmaSquaredWinLose <$-$ var( totals[n,]) 
 
    victory <$-$ 4 
    ruin <$-$ $-$4 
    victoryOrRuin <$-$ array(0, dim(k)) 
    hitVictory <$-$ apply( (totals >= victory), 2, which) 
    hitRuin <$-$ apply( (totals <= ruin), 2, which) 
    victoryOrRuin <$-$ array(0, dim = c(k)) 
 
    hitVictory <$-$ apply( (totals >= victory), 2, which) 
    hitRuin <$-$ apply( (totals <= ruin), 2, which) 
 
    for (j in 1:k) { 
       if ( length(hitVictory[[j]]) == 0 
            && length(hitRuin[[j]]) == 0 ) { 
         # no victory, no ruin 
         # do nothing 
       } 
       else if ( length(hitVictory[[j]]) > 0 
                 && length(hitRuin[[j]]) == 0 ) { 
         # victory, no ruin 
         victoryOrRuin[j] <$-$ min(hitVictory[[j]]) 
         } 
       else if ( length(hitVictory[[j]]) == 0 
                 && length(hitRuin[[j]]) > 0 ) { 
         # no victory, ruin 
         victoryOrRuin[j] <$-$ $-$min(hitRuin[[j]]) 
         } 
       else # ( length(hitVictory[[j]]) > 0 
                && length(hitRuin[[j]]) > 0 ) 
         # victory and ruin 
         if ( min(hitVictory[[j]]) < min(hitRuin[[j]]) ) { 
           # victory first 
           victoryOrRuin[j] <$-$ min(hitVictory[[j]]) 
           # code hitting victory 
         } 
         else {  # ruin first 
           victoryOrRuin[j] <$-$ $-$min(hitRuin[[j]]) 
           # code hitting ruin as negative 
         } 
    } 
 
    victoryBeforeRuin <$-$ sum(0+(victoryOrRuin > 0)) 
    # count exits through top 
    ruinBeforeVictory <$-$ sum(0+(victoryOrRuin < 0)) 
    # count exits through bottom 
    noRuinOrVictory   <$-$ sum(0+(victoryOrRuin == 0)) 
 
    avgTimeVictoryOrRuin <$-$ mean( abs(victoryOrRuin) ) 
    varTimeVictoryOrRuin <$-$ var( abs(victoryOrRuin) ) 
 
    hist( victoryOrRuin, 
        nclass = 2∗max(abs(victoryOrRuin))+1 ) 
    # sample exit time distribution

Octave

      p = 0.5; 
      n = 15; 
      k = 10; 
 
      coinFlips = rand(n,k) <= p; 
      headsTotal = sum(coinFlips); 
      # 0..n binomial rv sample, size k 
      muHeads = mean(headsTotal) 
      # Expected value is n/2 
      sigmaSquaredHeads = var(headsTotal) 
      # Theoretical value is np(1$-$p) 
 
      winLose = 2∗coinFlips $-$ 1; 
      # $-$1 for Tails, 1 for Heads 
      totals = cumsum(winLose); 
      # $-$n..n (every other integer) binomial rv sample 
      mu_winlose = mean( totals(n,:) ) 
      # Expected value is 0 
      sigmaSquaredwinLose = var( totals(n,:) ) 
      # Theoretical value is 4np(1$-$p)

      victory =  4; 
      # top boundary for random walk 
      ruin    = $-$4; 
      # bottom boundary for random walk 
 
      # Octave find treats a whole matrix as a single column, 
      # Need to treat the experiment column by column, 
      # so here is a place where for clarity, 
      # better to loop over columns, using find on each 
      victoryOrRuin = zeros(1,k); 
      for j = 1:k 
          hitVictory = find(totals(:,j) >= victory); 
          hitRuin  = find(totals(:,j) <= ruin); 
          if ( !rows(hitVictory) && !rows(hitRuin) ) 
             # no victory, no ruin 
             # do nothing 
          elseif ( rows(hitVictory) && !rows(hitRuin) ) 
             # victory, no ruin 
             victoryOrRuin(j) = hitVictory(1); 
          elseif ( !rows(hitVictory) && rows(hitRuin) ) 
             # no victory, but hit ruin 
             victoryOrRuin(j) = $-$hitRuin(1); 
          else # ( rows(hitvictory) && rows(hitruin) ) 
             # victory and ruin 
             if ( hitVictory(1) < hitRuin(1) ) 
               victoryOrRuin(j) = hitVictory(1); 
               # code hitting victory 
             else 
               victoryOrRuin(j) = $-$hitRuin(1); 
               # code hitting ruin as negative 
             endif 
          endif 
      endfor 
 
      victoryOrRuin 
      # display vector of k hitting times 
 
      victoryBeforeRuin = sum( victoryOrRuin > 0 ) 
 
 
      # count exits through top 
      ruinBeforeVictory = sum( victoryOrRuin < 0 ) 
      # count exits through bottom 
      noRuinOrVictory   = sum( victoryOrRuin == 0 ) 
 
      avgTimeVictoryOrRuin = mean( abs(victoryOrRuin) ) 
      varTimeVictoryOrRuin = var( abs(victoryOrRuin) ) 
 
      max(totals) 
      hist( victoryOrRuin, max(max(victoryOrRuin))) 
      # sample exit time distribution

Perl Data Language

      use PDL; 
      $p = 0.5; 
      $n = 15; 
      $k = 10; 
      $coinFlips = random($k,$n) >= $p 
      #note order of dims!! 
      $headsTotal = $coinFlips$-$>transpose$-$>sumover 
      #note transpose, PDL likes x (row) direction for operations 
      ($muHeads,$prms,$median,$min,$max,$adev,$rmsHeads) = 
          $headsTotal$-$>stats; 
      # easiest way to get the descriptive statistics 
      print $muHeads 
      p $varHeads = $rmsHeads ∗ $rmsHeads 
 
      $winLose = 2 ∗ $coinFlips $-$1;  # note use of threading 
      $totals = (cumusumover $winLose$-$>xchg(0,1))$-$>transpose 
      # note xchg transpose, PDL likes x (row) direction 
      # as default for operations 
      ($muTotals,$prms,$median,$min,$max,$adev,$rmsTotals) = 
          $totals(0:$k$-$1,$n$-$1)$-$>stats; 
      # pdl are indexed from 0 like C and Perl, 
      # so that’s why $k$-$1, $n$-$1 
      print $muTotals; 
      $varTotals = $rmsTotals ∗ $rmsTotals 
      print $varTotals; 
 
      $victory = 4; 
      $ruin = $-$4; 
      $victoryOrRuin = zeros($k); 
      $whenVictory = ($totals >= $victory); 
      $whenRuin = ($totals <= $ruin); 
 
      p $whenVictory(0,:)$-$>which$-$>min; 
      p $whenRuin(0,:)$-$>which$-$>min;

SciPy

      import scipy 
 
      p = 0.5 
      n = 15 
      k = 10 
 
      coinFlips = scipy.random.random((n,k))>= p 
      # Note Booleans True for Heads and False for Tails 
      headsTotal = scipy.sum(coinFlips, axis = 0) 
      # Note how Booleans act as 0 (False) and 1 (True) 
      muHeads = scipy.mean(headsTotal) 
      stddevHeads = scipy.std(headsTotal) 
      varHeads = stddevHeads ∗ stddevHeads 
      print muHeads, varHeads 
 
      winLose = 2∗coinFlips $-$ 1 
      totals = scipy.cumsum(winLose, axis = 0) 
      muTotals = scipy.mean(totals[n$-$1,range(k)]) 
      stddevTotals = scipy.std(totals[n$-$1, range(k)]) 
      varTotals = stddevTotals ∗ stddevTotals 
      print muTotals, varTotals 
 
      victory = 4; 
      ruin = $-$4; 
 
      victoryOrRuin = scipy.zeros(k,int); 
      hitVictory = scipy.argmax( (totals >= victory), axis=0) 
      hitRuin = scipy.argmax( (totals <= ruin), axis=0) 
      for i in range(k): 
          if hitVictory[i] == 0 and  hitRuin[i] == 0: 
              # no victory, no ruin, do nothing 
              victoryOrRuin[i] = 0 
          elif hitVictory[i] > 0 and  hitRuin[i] == 0: 
              victoryOrRuin[i] = hitVictory[i] 
          elif hitVictory[i] == 0 and  hitRuin[i] > 0: 
              victoryOrRuin[i] = $-$hitRuin[i] 
          else: 
              if hitVictory[i] < hitRuin[i]: 
                  victoryOrRuin[i] = hitVictory[i] 
              else: 
                  victoryOrRuin[i] = $-$hitRuin[i] 
 
      hitVictoryBeforeRuin = scipy.sum( hitVictory > 0 ) 
      hitRuinBeforeVictory = scipy.sum( hitRuin < 0 ) 
      noVictoryOrRuin = scipy.sum( victoryOrRuin == 0 ) 
 
      avgTimeVictoryOrRuin = 
          scipy.mean(scipy.absolute(victoryOrRuin)) 
      stddevVictoryOrRuin = 
          scipy.std(scipy.absolute(victoryOrRuin)) 
      varVictoryOrRuin = 
          stddevVictoryOrRuin ∗ stddevVictoryOrRuin 
 
      (testhist, testbins) = 
          scipy.histogram(victoryOrRuin, 
          2∗scipy.absolute(victoryOrRuin).max())

__________________________________________________________________________

Problems to Work for Understanding

1. How many heads were obtained in your sequence of 100 flips? What is the class average of the number of heads in 100 flips? What is the variance of the number of heads obtained by the class members?
2. What is the net win-loss total obtained in your sequence of 100 flips? What is the class average of the net win-loss total in 100 flips? What is the variance of the net win-loss total obtained by the class members?
3. How many of the class reached a net gain of $+10$ (call it victory) before reaching a net loss of $-10$ (call it ruin)?
4. How many flips did it take before you reached a net gain of $+10$ (victory) or a net loss of $-10$ (ruin)? What is the class average of the number of flips before reaching vitory before ruin at $+10$ or a net loss of $-10$?
5. What is the maximum net value achieved in your sequence of flips? What is the class distribution of maximum values achieved in the sequence of flips?
6. Perform some simulations of the coin-flipping game, varying $p$. How does the value of $p$ affect the experimental probability of victory and ruin?

__________________________________________________________________________

Reading Suggestion:

References

__________________________________________________________________________

Outside Readings and Links:

1. Virtual Laboratories in Probability and Statistics Red and Black Game.
2. University of California, San Diego, Department of Mathematics, A.M. Garsia. A java applet that simulates how long it takes for a gambler to go broke. You can control how much money you and the casino start with, the house odds, and the maximum number of games. Results are a graph and a summary table. Submitted by Matt Odell, September 8, 2003.

__________________________________________________________________________

I check all the information on each page for correctness and typographical errors. Nevertheless, some errors may occur and I would be grateful if you would alert me to such errors. I make every reasonable effort to present current and accurate information for public use, however I do not guarantee the accuracy or timeliness of information on this website. Your use of the information from this website is strictly voluntary and at your risk.

I have checked the links to external sites for usefulness. Links to external websites are provided as a convenience. I do not endorse, control, monitor, or guarantee the information contained in any external website. I don’t guarantee that the links are active at all times. Use the links here with the same caution as you would all information on the Internet. This website reflects the thoughts, interests and opinions of its author. They do not explicitly represent official positions or policies of my employer.

Information on this website is subject to change without notice.

Steve Dunbar’s Home Page, http://www.math.unl.edu/~sdunbar1

Email to Steve Dunbar, sdunbar1 at unl dot edu

Last modified: Processed from LATEX source on April 11, 2012