Featured

The Strange Prisoner Experiment

100 prisoners are sent into a room, one by one. In this room there are as many boxes as there are prisoners and each prisoner can open half the boxes in the room. Each box contains a random number and if the prisoner finds his number in any of the 50 boxes he is allowed to open, he succeeds. Each prisoner must leave the room exactly as he found it and cannot communicate  with any of the other prisoners after he's done. If any of the 100 prisoners fails, they all get executed.

The question: Is there a strategy the prisoners can agree on before the first prisoner enters the room to increase their chances of winning?
The proposed solution: Each prisoner opens the box with his number as the label first and then moves to the box with the number he finds inside that box.

For example, prisoner no. 10 enters the room, he opens box no. 10, if he indeed finds number 10 inside that box, he is done, if not he should open the box with the number he found inside box no 10 and so on.

I thought: maybe that's just one a theoretical probability experiment that only works in theory, so I whipped up this python script to test the hypothesis. I did not double-check how low the win rate is, when all prisoners pick boxes at random, because the math is pretty straight forward, so I'll assume Veritasium is right and the result it's very very low.

``````import numpy as np
import random
import time

print(100*"=")

prisoners = 100 # set number of prisoners here

def run(l):
for i in range(prisoners):
success = send_prisoner(l, i) #
if not success:
return False, i # i prisoners found their box before 1 failed

return True, prisoners

def send_prisoner(l, prisoner):
# let 1 prisoner search the boxes
for i in range(prisoners // 2): # each prisoner can check half the amount of boxes as there are prisoners
#print("Checking", next_box, "found:", l[next_box]) #uncomment to check if they march in loops
if l[next_box] == prisoner:
#print("Found it, tries", i) # uncomment to see how many tries it took each prisoner
return True
next_box = l[next_box]
return False

def get_boxes():
boxes = []
for i in range(prisoners):
boxes.append(i)
random.shuffle(boxes)
return boxes

# returns as many boxes as there are prisoners
boxes = np.arange(prisoners) # get a list of the numbers [0 ; prisoners -1]
np.random.shuffle(boxes) #shuffle the numbers inside the boxes
return boxes

def main():
successes = 0
total_successes = 0
start_time = time.time()
n = 1000 # how many times the warden gets his sadism on
for i in range(n):
l = get_boxes()
success, total = run(l) # run 1 experiment
#print("Run no:", i, "successes:", total)
total_successes += total
if success:
successes += 1

end_time = time.time()

win_ratio = successes / n
total_completed = total_successes / (prisoners * n)
print("Total prisoners that succeeded", total_successes, "out of: ", (prisoners * n), "=>", total_completed)
print("Win ratio:", str(round(win_ratio * 100, 3)) + '%')
print("Method took:", end_time - start_time) # so you can plan ahead how much time it would take to increase either n or prisoners

if __name__ == "__main__":
main()``````

Running the plotted script below with n = 100,000 resulted in:

Prisoners: 2, Win rate 0.49721
Prisoners: 20, Win rate 0.32954
Prisoners: 50, Win rate 0.31907
Prisoners: 100, Win rate 0.31063
Prisoners: 200, Win rate 0.30901
Prisoners: 500, Win rate 0.30874
Prisoners: 1000, Win rate 0.30913

As you would expect, running the experiment 100 times is not sufficient to be statistically reliable. That would be like throwing a dye 6 times and expecting each number exactly once. This means we get a lot of fluctuation.

Using 1,000 iterations brings us closer to the truth and 100,000 should be sufficient to show that just like Eric claimed 100 prisoners have a success rate of ~31.1% and 1,000 still survive ~30.6% of the time.

And this wouldn't be BlenderDiplom if we would not provide the method we used to plot this in Blender, here is the script:

``````import random
import time

from bpy import data as D
from bpy import context as C
from mathutils import Vector

print(100*"=")

def run(l, prisoners):
for i in range(prisoners):
success = send_prisoner(l, i) #
if not success:
return False, i # i prisoners found their box before 1 failed

return True, prisoners

def send_prisoner(l, prisoner):
# let 1 prisoner search the boxes
length = len(l) // 2
for i in range(length): # each prisoner can check half the amount of boxes as there are prisoners
#print("Checking", next_box, "found:", l[next_box]) #uncomment to check if they march in loops
if l[next_box] == prisoner: # number inside the box equals the number of the current prisoner
#print("Found it, tries", i) # uncomment to see how many tries it took each prisoner
return True
next_box = l[next_box]
return False

def get_boxes(prisoners):
# returns as many boxes as there are prisoners
boxes = []
for i in range(prisoners):
boxes.append(i)
random.shuffle(boxes)
return boxes

def run_experiment(prisoners, n):
team_successes = 0 # number of times all prisoners succeded
start_time = time.time()
results = []

for i in range(n):
l = get_boxes(prisoners)
success, total = run(l, prisoners) # run 1 experiment
#print("Run no:", i, "successes:", total)
if success:
team_successes += 1

win_ratio = team_successes / n
return win_ratio

def plot(results, distance):
mesh = D.meshes['Plane'] # the base mesh for the bar, add a plane and scale it in Edit Mode
collection = D.collections['Plot']
txt_mat = None
bar_mat = None
if not 'Label' in D.materials:
txt_mat = D.materials.new('Label')
else:
txt_mat = D.materials['Label']

for i, result in enumerate(results):
prisoners = result['prisoners']
print("Prisoners", prisoners, "Win rate", result['win_ratio'])
label = str(prisoners)
txt = D.curves.new(type="FONT", name = 'Label-' + label) # need to use a font curve as object data
txt.body = label
txt.align_x = 'CENTER'
txt_ob = D.objects.new('Label-' + label, txt) # curve here, text does not work directly
txt_ob.data.materials.append(txt_mat) # so you can change the appearance of all labels at once

x = i * distance # evenly space the results
txt_ob.location = Vector((x, -1.2, 0)) #hardcoded values that fit the current setup
txt_scale = 1.3
txt_ob.scale = Vector((txt_scale, txt_scale, txt_scale))
bar = D.objects.new('Bar-' + label, mesh)
bar.scale = Vector((1, result['win_ratio'] * 20, 1))
bar.location = Vector((x, 0, 0))

def main():
start_time = time.time()
results = []
current_prisoners = [2, 20, 50, 100, 200, 500, 1000]
n = 100 # how many times the warden gets his sadism on
for prisoners in current_prisoners:
win_ratio = run_experiment(prisoners, n)
result = { # use a struct to link the current no of prisoners to their win ratio
'prisoners' : prisoners,
'win_ratio' : win_ratio
}
results.append(result)
print(prisoners, "prisoners:", win_ratio)
end_time = time.time()
print("Calculations took:", end_time - start_time) # in sec so you can plan ahead how much time it would take to increase either n or prisoners
distance = 4 # spacing between 2 bars
plot(results, distance)

if __name__ == "__main__":
main()``````

You can probably use parts of it as snippets and even if not, it might still help you to evade the pit-fall that bpy.data.texts.new() does not create object data, you need to create a curve object data with type='FONT'.