We are sending a one bit message to someone. There is a 60% chance the message bit will be a 0. When transmitting the message there is a 3% chance a 1 will become a 0. There is a 5% chance a 0 will become 1 when transmitting.

Lets say we take our original message duplicate the bit 3times ie 1 -> [1,1,1] we then transmit that message to someone. What is the probability they will receive the incorrect message using majority rule to decide what the correct bit in the message was?

Now I am very bad at statistics but I created an experiment to try to determine this value with the following python code Library:

import random as r
import numpy as np
import matplotlib
import matplotlib.pyplot as plt


#p0 is the probability a bit will be 0 and size is the size of the message you wish to create
def createmessage(p0,size):
    rands = np.random.rand(size)
    msg = []
    #we parse through a big numpy array of the rands to ammortize costs in efficent c-code
    for rand in rands:
        if rand <= p0:
            msg.append(0)
        else:
            msg.append(1)
    return msg
#e0 probability that a 0 will be recieved as 1. e1 is the probability a 1 will be recieved as a 0
def transmitmessage(e0,e1,source):
    received = source.copy()
    rands = np.random.random(len(source))
    msg = []
    index = 0
    #we ammortize costs again and modify a copied version of our source
    for bit in source:
        if bool(bit):
            if rands[index] <= e1:
                received[index] = 0
        else:
            if rands[index] <= e0:
                received[index] = 1
        index+=1
    return received

The experiment:

import random as r
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
from lab2lib import createmessage,transmitmessage

samplesize = 100000
p0 = 0.6
e0 = 0.05
e1 = 0.03
message = createmessage(p0,samplesize)
redundancy = []
for bit in message:
    for x in range(3):
        redundancy.append(bit)

received = transmitmessage(e0,e1,redundancy)

failures = 0
index = 0
#for every bit in our message we had an error if the bit in the source message is not equal to the bit in the recieved message
for index in range(0,len(message),3):
    majoritybit = -1
    if received[index]+received[index+1]+received[index+2] >= 2:
        majoritybit = 1
    else:
        majoritybit = 0
    if majoritybit != message[index//3]:
        failures+=1
        print(f"Bits in dispute,  Source at index {index}: {message[index//3]} 3 bits that disagree [{received[index]},{received[index+1]},{received[index+2]}]")


print(f"failures:{failures}")
print(f"failure rate: {failures/samplesize}")

My answers im getting is like this

These answers are not lining up with someone else in my class who is doing the same experiment but we can't find fault in either person code. So I am here beseeching the stat gods.

Part A