Outline

• Generating Random Permutations
• In-Class Exercise
• Birthday Problem
• Ball and Bins Arguments

Introduction

• On Monday, we were looking at the hiring problem which was to work out the total cost of interviewing `n` candidates, where if we find candidate `i` is better than the current best candidate we fire current best and hire `i`.
• We assumed there was a cost `c_i` to interview a candidate and a code `c_h\>\>c_i` to hire and fire and candidates.
• We worked out that the expected total cost would be `O(c_i n + c_h ln n)` provided that the order of arriving candidates was chosen uniformly at random.
• In order to ensure this situation, we said we would generate a random permutation and apply it to the candidate order, then start the interview process.
• We gave one algorithm for generating random permutations by first randomly picking priorities from 1 to `n^3` and then sorting by these priorities.
• We showed this `O(n\cdot log n)` algorithm generates a permutation uniformly at random from the set of permutations provided all the priorities are distinct.
• We start today by showing that with high probability all of the priorities will be distinct.

More on Method 1

• What do we do if the priorities aren't all distinct?
• Well, we just try again and draw a new list of priorities.
• What's the likelihood this bad situation happens?

Claim. The probability that all the priorities are unique is at least 1- 1/n.

Proof. Let `X_i` be the indicator that the `i`th priority was unique. Again,
`Pr{X_1 cap ... cap X_n} = Pr{X_1} cdot Pr{X_2|X_1} cdots Pr{X_n | X_1 cap ... cap X_(n-1)}`.
`= n^3/n^3 cdot (n^3 -1)/n^3 cdots (n^3 - (n-1))/n^3`
`ge (n^3 -n)/n^3 cdot (n^3 -n)/n^3 cdots (n^3 -n)/n^3`
`= (1 - 1/n^2)^(n-1)`
`ge 1 - (n-1)/n^2` as `(1-a)(1-b) > 1 - a - b` if `a` and `b` nonnegative.
`> 1 - 1/n`

Randomly Permuting Arrays (Method 2)

Randomize-In-Place(A) 
1. n := length[A]
2. for i :=1 to n
3.     swap(A[i], A[Random(i,n)])

• A precursor to the above where one generates random numbers between 1 and n, write it to the output and strike it from the list to choose from is due to Fisher-Yates 1938, so the above is sometimes called a Fisher-Yates Shuffle.
• Durstenfeld 1964 came up with the version above.
• The version above was first popoularized in Knuth, The Art of Programming, 1968, so is sometimes also called a Knuth Shuffle.
• Unlike Method 1 it is linear time, so suitable for use in our randomized hiring algorithm.
• On the hand, Method 1 is much more parallelizable than Method 2, so also has its uses.

Analysis of Method 2

Lemma. Just prior to the ith iteration of the for loop, for each possible `(i-1)`-permutation, the subarray `A[1,i-1]` contains this permutation with probability `((n-i+1)!)/(n!)`

Proof. By induction on `i`.

Base case: When `i=1`, `A[1..0]` is the empty array. It is supposed to contain a given 0-permutation with probability `((n-1+1)!)/(n!) = (n!)/(n!)=1`. As a `0`-permutation has no elements and there is only one of them this is true.

Induction step: Assume just before the `i`th iteration, each `(i-1)`-permutation occurs in `A[1..i-1]` with probability `((n-i+1)!)/(n!)`. A particular, `i`-permutation `langle x_1,...,x_(i-1), x_i rangle` consists of an `(i-1)`-permutation followed by `x_i`. By the induction hypothesis, the probability of the `i`-permutation is thus
`[((n-i+1)!)/(n!)] cdot Pr{A[i]= x_i| A[1..i-1] = langle x_1,...,x_(i-1) rangle}`.
The second factor is `1/(n-i+1)` since by line 3 of Randomize-in-Place, `x_i` is choosen at random from `A[i..n]`. So the probability of the `i`-permutation is
`((n-i+1)!)/(n!) cdot 1/(n-i+1) = ((n-i)!)/(n!)` as desired.

More Analysis of Method 2

Theorem. Randomize-In-Place produces a uniformly chosen random permutation.

Proof. The program could generate any `n`-permutation. Further it terminates just before its `(n+1)`st iteration and thus by the lemma generates a given random `n`-permutation with probability:
`((n - (n+1) +1)!)/(n!) = (0!)/(n!) = 1/(n!)`
as desired.

In-Class Exercise

• Suppose `n` devices are on a network. These devices each have access to a random noise source (and hence, a random number generator) not correlated with any other device.
• Whatever `n` is, we know that it is less than 4 billion.
• Each device wants to assign itself a unique identifier that is not used by any other device, but is not allowed to communicate with any other device to establish this.
• Ideally, the identifier should be as small as possible.
• Give an algorithm to choose an identifier less than 96 bits long that succeeds in giving all devices a unique identifier with probability greater than 0.999999999.
• Argue why your algorithm works.
• Post your solutions to the Feb 2 In-Class Exercise Thread.

The Birthday Problem

How many people must there be in a room before there is a `50%` chance that two were born on the same day of the year?

• Let `b_1, b_2,.., b_k` be the birthday's for the people in the room. These are independent random events.
• Let `n` be the number of days in a year. (i.e., `n=365`). Let `r` be the `r`th day of year.
• Assume `Pr{birthday(b_i) = r}= 1/n.`
• `Pr{mbox(birthday)(b_i) = r ^^ mbox(birthday)(b_j)=r} = Pr{mbox(birthday)(b_i) = r} cdot Pr{mbox(birthday)(b_j) = r} = 1/(n^2)`.
• So the probability any `b_i` and `b_j` have any day `r` as their birthday is:
  `Pr{mbox(birthday)(b_i) = mbox(birthday)(b_j)} =`
  `= sum_(r=1)^n Pr{mbox(birthday)(b_i) = r} cdot Pr{mbox(birthday)(b_j) = r}`
  `= sum_(r=1)^n 1/(n^2)`
  `= 1/n`.

More on the Birthday Problem

• To determine the odds of whether at least two out of the `k` people have matching birthday, we look at the complementary event: What are the odds that no-one shares a birthday?
• Let `A_i` indicate that for no `j lt i`, do `b_j` and `b_i` have the same birthday.
• Define `B_1=A_1` and `B_(i+1)= A_(i+1) cap B_i`.
• So `Pr{B_k} = Pr{B_(k-1)} cdot Pr{A_k|B_(k-1)}`
  `= Pr{B_1}Pr{A_2|B_1}cdot cdots cdot Pr{A_k|B_(k-1)}`
  `= 1 (1- 1/n)(1- 2/n) cdot cdots cdot (1 - (k-1)/n)`
  Now we can use `1+x le e^x` to get this is less than
  `e^(-1/n)e^(-2/n)cdot cdots cdot e^(-(k-1)/n) = e^(-(1/n)*(1+2+ cdots +(k-1)) = e^((-k(k-1))/(2n))`
  which is less than `1/2` if `(-k(k-1))/(2n) le -ln 2`.
• Solving for `k` using the quadratic formula, this implies `k>= [1+(1+ (8 ln 2)*n)^(1/2) ]/2`.
• When `n=365`, this yields `k >=23`.

Number of Expected Shared Birthdays

• Rather than look at the odds that two people share a birthday, we might ask the related question: For a given class size how many shared birthdays would we expect to see?
• Let \begin{eqnarray*} X_{ij} & = & I\{\mbox{person } i \mbox{ and person } j \mbox{ have the same birthday}\}\\ & = & \left\{ \begin{array}{ll} 1 & \text{if person $i$ and person $j$ have the same birthday}\\ 0 & \text{otherwise.} \end{array} \right. \end{eqnarray*}
• `E[X_(ij)] = Pr\{\text{person i and person j have the same birthday} \} = 1/n`.
• Let `X = sum_(i=1)^(k)sum_(j=i+1)^k X_(ij)`.
• So
  `E[X] = E[\sum_{i=1}^k\sum_{j=i+1}^k X_{ij}]`
  `= \sum_{i=1}^k\sum_{j=i+1}^kE[X_{ij}]`
  `= ((k),(2))1/n = \frac{k(k-1)}{2n}`
  using linearity of expectations.
• When `n=365`, this is greater than 1 if `k=28`