Expected number of moves needed to turn on all the n bulbs by tossing a baised coin with p% probability? - probability

Question

There are n bulbs. Initially, each bulb are turned off. In each move you can select one random bulb (Probability of selecting each bulb is same). If the bulb is already turned on, you do nothing. If the bulb is turned off, you must toss a coin. If it’s head, you can turn the bulb on, but if it’s tail, the bulb will remain off.
To make the problem even more boring, the coin is not a fair coin, the chance of landing a tail is p%.
What is the expected number of moves needed to turn on all the bulbs?
I want to know the algorithm or solution process for it as n is variable for this problem.

Answer 1

Naive approach: Monte-Carlo-Simulation
Description
(You did not give any information on what kind of solution you want, therefore i present the probably most simple but still powerful approach: simulation)
The Monte-Carlo method allows us to simulate this stochastic-process and observe the number of steps needed. As this is only a noisy estimation, we need to do this many times. Using an infinite number of runs, this solution will converge to the theoretical one!
Code
Here is some simple python-based code:
import random
import matplotlib.pyplot as plt # just for plotting
n = 10
p = 0.7
n_samples = 1000000
def run():
states = [0 for i in range(n)]
steps = 0
while 0 in states:
index = random.randint(0, n-1)
if random.random() < p: # non-fair coin
states[index] = 1
steps += 1
return steps
avg = 0.0
samples = []
for sample in range(n_samples):
steps = run()
avg += steps
samples.append(steps)
print(avg / n_samples)
plt.hist(samples)
plt.show()
Code output
41.853233
Math approach: Absorbing Markov Chain
Description
As the probabilities describing the state-change of light-bulbs is only dependent on the current state, the Markov-assumption is valid and we can use Markov-Chains to obtain the average steps needed.
Because the final state will self-loop forever and because it will be reached given an infinite number of steps, this is an Absorbing Markov Chain.
As all light bulbs are the same, we don't need to model transitions where each combination of activated light bulbs maps to each other. We can reduce it to the much simpler: 0 light-bulbs -> 1 light-bulbs -> ... (and the self-loops of course).
The discrete-time discrete-state-space Absorbing Markov Chain allows a simple and powerful calculation of the desired value.
Some theory is explained at wikipedia. It's also the source for the formulas in use for the following code.
Code
Again some python:
import numpy as np
N = 10
P = 0.7
""" Build transition matrix """
trans_mat = np.zeros((N+1, N+1))
for source_state in range(N):
prob_hitting_next = ((N-source_state) / float(N)) * P
inverse = 1.0 - prob_hitting_next
trans_mat[source_state, source_state] = inverse
trans_mat[source_state, source_state+1] = prob_hitting_next
trans_mat[N, N] = 1.0
""" Will look like this:
[[ 0.3 0.7 0. 0. 0. 0. 0. 0. 0. 0. 0. ]
[ 0. 0.37 0.63 0. 0. 0. 0. 0. 0. 0. 0. ]
[ 0. 0. 0.44 0.56 0. 0. 0. 0. 0. 0. 0. ]
[ 0. 0. 0. 0.51 0.49 0. 0. 0. 0. 0. 0. ]
[ 0. 0. 0. 0. 0.58 0.42 0. 0. 0. 0. 0. ]
[ 0. 0. 0. 0. 0. 0.65 0.35 0. 0. 0. 0. ]
[ 0. 0. 0. 0. 0. 0. 0.72 0.28 0. 0. 0. ]
[ 0. 0. 0. 0. 0. 0. 0. 0.79 0.21 0. 0. ]
[ 0. 0. 0. 0. 0. 0. 0. 0. 0.86 0.14 0. ]
[ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.93 0.07]
[ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. ]]
"""
""" Q: the sub-matrix of trans_mat without
the rows and columns of any absorbing states
N_fund: fundamental matrix
t: expected number of steps before beeing absorved for each start-state
"""
Q_sub = trans_mat[:N, :N]
N_fund = np.linalg.inv(np.eye(N) - Q_sub)
t = np.dot(N_fund, np.ones(N))
print(t)
print(t[0]) # this is the value we want
Code output
[ 41.84240363 40.4138322 38.82653061 37.04081633
35. 32.61904762 29.76190476 26.19047619 21.42857143 14.28571429]
41.8424036281 # less than 1 second calculation time!