Problem $3($Alice$,$ Bob and Bell's Inequality$)$

In this problem, we will implement the protocol between Alice and Bob that was described in the video lecture on Bell's inequality. We would like you to examine that lecture video before attempting it$.$

Alice and Bob are each given a classical bit and a qubit $1,1$b$1,$q$1$ for Alice and $2,2$b$2,$q$2$ are Bob.

The classical bits are each the result of the toss of a fair coin. But these are not yet revealed to Alice$/$Bob$.$

The qubits of Alice$/$Bob are entangled so that $||12=12(||00+||11)|$q$1$q$2=12(|00+|11).$

At a given moment in time, each of them gets to know their own bits.

They need to respond back with answers in the form of classical bits $1,2$z$1,$z$2$

They win if $12=12$b$1$b$2=$z$1$z$2.$

The best they can do without the aid of qubits is a winning probability of $0\mathrm{.}750\mathrm{.}75$ that can be obtained by simply each responding with a $00($the only way they lose is if $1=2=1$b$1=$b$2=1$ which is assumed to happen with $1/41/4$ probability$).$

We showed a protocol in the video that allows them to beat the classical probability limit$.$ Your goal is to implement that as part of a quantum circuit.

Implement the function alice$\_$response$($qcircuit$,$ b$1,$ qbit, cbit$)$ that inputs a the coin toss result for alice b$1,$ Alice's qubit qbit $($entangled with Bob's but that does not matter here$)$ and a classical bit to measure into. There is no need to return any results: we will take care of that in the testing code where we will read the classical bit as cbit as Alice's response.

Implement similarly the function bob$\_$response$($qcircuit$,$ b$2,$ qbit, cbit$)$ for Bob.

this is what I have so far:

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister

def create$\_$entangled$\_$state$($qc$)$:

qc$.$h$(0)$ # Apply Hadamard to the first qubit

qc$.$cx$(0,1)$

def alice$\_$response$($qc$,$ b$1,$ qbit, cbit$)$:

# If Alice's bit is $1,$ apply Hadamard

if b$1==1$:

qc$.$h$($qbit$)$ # Create superposition

# Measure the qubit

qc$.$measure$($qbit$,$ cbit$)$

def bob$\_$response$($qc$,$ b$2,$ qbit, cbit$)$:

# If Bob's bit is $1,$ apply Y gate

if b$2==1$:

qc$.$y$($qbit$)$ # Change measurement basis

# Measure the qubit

qc$.$measure$($qbit$,$ cbit$)$

this is the test cell that I can't change. My code won't pass the 'create$\_$and$\_$run$\_$circuit$($False$,$ True$)$:

from qiskit import transpile, Aer, QuantumRegister, ClassicalRegister, QuantumCircuit

def create$\_$and$\_$run$\_$circuit$($b$1,$ b$2)$:

# let's collect the counts for b$1=1,$ b$2=1$

qbits$11=$ QuantumRegister$(2,$ 'qbit'$)$

cbits$11=$ ClassicalRegister$(2,\text{'}$z$\text{'})$

# create the bell state

print$($f$\text{'}$Circuit for b$1=\{$b$1\}$ and b$2=\{$b$2\}\text{'})$

qc$\_11=$ QuantumCircuit$($qbits$11,$ cbits$11)$

qc$\_11.$h$($qbits$11[0])$

qc$\_11.$cx$($qbits$11[0],$ qbits$11[1])$

qc$\_11.$barrier$()$

alice$\_$response$($qc$\_11,$ b$1,$ qbits$11[0],$ cbits$11[0])$

bob$\_$response$($qc$\_11,$ b$2,$ qbits$11[1],$ cbits$11[1])$

display$($qc$\_11.$draw$(\text{'}$mpl$\text{'},$ style$=$'iqp'$))$

# simulate

# test

simulator $=$ Aer.get$\_$backend$(\text{'}$aer$\_$simulator'$)$

circ$11=$ transpile$($qc$\_11,$ simulator$)$

# Run and get counts

result $=$ simulator.run$($qc$\_11).$result$()$

counts $=$ result.get$\_$counts$($circ$11)$

print$($counts$)$

return counts

success$\_$count $=0$

counts $=$ create$\_$and$\_$run$\_$circuit$($True$,$ True$)$

assert $\text{'}01\text{'}$ in counts, 'Your result for b$1=$ True and b$2=$ True must have non$-$zero amplitude for $|01>\text{'}$

assert $\text{'}10\text{'}$ in counts, 'Your result for b$1=$ True and b$2=$ True must have non$-$zero amplitude for $|10>\text{'}$

success$\_$count $+=($counts$[\text{'}01\text{'}]+$ counts$[\text{'}10\text{'}])$

counts $=$ create$\_$and$\_$run$\_$circuit$($True$,$ False$)$

assert $\text{'}00\text{'}$ in counts, 'Your result for b$1=$ True and b$2=$ False must have non$-$zero amplitude for $|01>\text{'}$

assert $\text{'}11\text{'}$ in counts, 'Your result for b$1=$ True and b$2=$ False must have non$-$zero amplitude for $|10>\text{'}$

success$\_$count $+=($counts$[\text{'}00\text{'}]+$ counts$[\text{'}11\text{'}])$

counts $=$ create$\_$and$\_$run$\_$circuit$($False$,$ True$)$

assert $\text{'}00\text{'}$ in counts, 'Your result for b$1=$ False and b$2=$ True must have non$-$zero amplitude for $|01>\text{'}$

assert $\text{'}11\text{'}$ in counts, 'Your result for b$1=$ False and b$2=$ True must have non$-$zero amplitude for $|10>\text{'}$

success$\_$count $+=($counts$[\text{'}00\text{'}]+$ counts$[\text{'}11\text{'}])$

counts $=$ create$\_$and$\_$run$\_$circuit$($False$,$ False$)$

assert $\text{'}00\text{'}$ in counts, 'Your result for b$1=$ False and b$2=$ False must have non$-$zero amplitude for $|01>\text{'}$

assert $\text{'}11\text{'}$ in counts, 'Your result for b$1=$ False and b$2=$ False must have non$-$zero amplitude for $|10>\text{'}$

success$\_$count $+=($counts$[\text{'}00\text{'}]+$ counts$[\text{'}11\text{'}])$

print$($f$\text{'}$Probability of Alice$/$Bob Winning is estimated to be: $\{$success$\_$count$/(4*1024)\}\text{'})$