Stochastic Programming - I (Interpreting basic probabilistic results)

This is my first Computer Science note so I would love a bit of feed back in the comments.

img1

\(\textbf{A Probabilistic World:}\)

The most comforting thing about Newtonian Mechanics is that everything happens for a reason.For example,if you push one end of the lever,the other end goes up.You throw an object and it travels in a parabolic path.The physical world is a completely deterministic place-all the future states are derived form the previous s ones.For centuries we had this prevailing scientific wisdom,then came the Copenhagen doctrine,led by Bohr and Heisenberg.The proponents of this doctrine argued that at the most fundamental level,the behavior of a physical system cannot be determined.This led to a serious debate regarding the validity of causal non-determinism,ie every event is not caused by previous events.People like Einstein and Schrodinger found this philosophy unacceptable as exemplified by Einstein's often repeated comment - "God does not play dice".The question of causal non-determinism is still unsettled but there is ample evidence to prove that certain systems can only be modeled accurately by stochastic processes.A process is called stochastic if it's next step depends on both previous states and some random event.

$\textbf{Interpreting basic results:}$

We all know how to calculate the basic probability of occurrence of certain events.But how do we interpret the significance of the results obtained?The answer is in this age of fast computers we can run multiple simulations of an event and record the outcomes and compare the results with the mathematically calculated value!Then in front of our own eyes we can see how powerful the theory of probability is!

img2

$\textbf{The Story of Blaise Pascal:}$

We all know that one of the most influential figures in the history of Probability Theory was Blaise Pascal.His interest in the field began when a friend asked him the following question

"Would it be profitable given 24 rolls of a pair of fair dice to bet against there being at least one double six"

Pascal and Fermat exchanged a number of letters to solve this issue which apparently looks easy in the 21st century.Let us calculate it.

The probability of rolling $6$ on one dice = $\frac{1}{6}$

The probability of rolling $6$ on both dice = $\frac{1}{6^{2}}$ = $\frac{1}{36}$

The probability of not rolling a double $6$ on first roll = $(1 - \frac{1}{36})$ = $\frac{35}{36}$

The probability of not rolling a double $6$ on 24 rolls = $(\frac{35}{36})^{24}$ = $0.508596123869$.

img3

$\textbf{The Law of Large Numbers:}$

It states that in repeated independent tests,with actual probability $p$ of a particular outcome in each test,the change that the fraction of times that outcome occurs differs from $p$ converges to $0$ as the number of trails go to infinity.

img4

In other words we are going to organize a large number of trails of Pascal's experiment and expect that the simulation results will get very close to the mathematically calculated value.

$\textbf{Constructing a Stochastic Program:}$

The programming language we are going to use is Python.We will use Python's random module to construct a program to check the results.It is given by the following code with the comments explaining each line.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import random

def rollDie():
    """returns a random int between 1 and 6"""
    return random.choice([1,2,3,4,5,6])

def checkPascal(numTrials,roll):
    yes = 0.0 #collector variable for favorable outcomes
    for i in range(numTrials): #executing trials
        for j in range(24): #rolling the pair 24 times
            d1 = roll() #rolling the first dice
            d2 = roll()  #rolling the second dice
            if d1 == 6 and d2 == 6:#checking favorable outcome
                yes += 1 #increasing the collector variable
                break
            print "Probability of losing",1 - (yes/numTrials)

checkPascal(10000,rollDie) # running the simulation 10000 times

When I ran the program, the outcome was $0.5067892$.Pretty close to Pascal's math!Try it out in a Python 2.7 interpreter!!

$\textbf{Footnotes:}$

This note was inspired by a chapter from "Introduction to Computaion and programming in Python" by John V.Guttag.

Those of you wondering about the matrix picture it is because the movie depicts the ultimate computer simulation.

img5