Quantum Information Theory and Quantum
Computing -Numerical Problems
1 PROBLEMS AND SOLUTIONS
1.1 PROBLEM 1
Alice wants to send 2 classical bits of information to Bob using quantum teleportation. How
many classical bits does she need to send to Bob after performing her measurement?
Solution:
1. In quantum teleportation, Alice needs to send the results of her Bell state measurement
to Bob.
2. A Bell state measurement has four possible outcomes.
3. To distinguish between four outcomes, Alice needs to send 2 classical bits.
4. Therefore, Alice needs to send 2 classical bits to Bob after her measurement.
1.2 PROBLEM 2
A quantum circuit consists of a Hadamard gate followed by a CNOT gate. If the input state is
$\ket{00}$, what is the output state?
Solution:
1. The Hadamard gate acts on the first qubit: $H\ket{0} = \frac{1}{\sqrt{2}}(\ket{0} +
\ket{1})$
2. After the Hadamard gate, the state is: $\frac{1}{\sqrt{2}}(\ket{00} + \ket{10})$
3. The CNOT gate flips the second qubit if the first qubit is $\ket{1}$
4. After the CNOT gate, the state becomes: $\frac{1}{\sqrt{2}}(\ket{00} + \ket{11})$
5. This is the Bell state $\ket{\Phi^+}$
1.3 PROBLEM 3
Calculate the von Neumann entropy of the mixed state $\rho = \frac{1}{3}\ket{0}\bra{0} +
\frac{2}{3}\ket{1}\bra{1}$.
Solution:
1. The von Neumann entropy is given by π(π)= βTr(πlog2π)
2. The eigenvalues of π are π1=1
3 and π2=2
3
3. π(π)= β(1
3log21
3+2
3log22
3)
4. Calculating this: π(π)β 0.9183 bits
1.4 PROBLEM 4
Alice and Bob share the Bell state $\ket{\Psi^-} = \frac{1}{\sqrt{2}}(\ket{01} - \ket{10})$.
They both measure their qubits in the computational basis. What is the probability that Alice
measures $\ket{0}$ and Bob measures $\ket{1}$?
Solution:
1. The probability is given by $|\bra{01}\Psi^-\rangle|^2$
2. $\bra{01}\Psi^-\rangle = \frac{1}{\sqrt{2}}$
3. Therefore, the probability is |1
β2|2=1
2= 0.5 or 50%
1.5 PROBLEM 5
Implement a quantum circuit that creates the GHZ state $\ket{GHZ} =
\frac{1}{\sqrt{2}}(\ket{000} + \ket{111})$ starting from $\ket{000}$.
Solution:
1. Start with $\ket{000}$
2. Apply a Hadamard gate to the first qubit: $\frac{1}{\sqrt{2}}(\ket{000} + \ket{100})$
3. Apply a CNOT gate with the first qubit as control and the second qubit as target:
$\frac{1}{\sqrt{2}}(\ket{000} + \ket{110})$
4. Apply another CNOT gate with the first qubit as control and the third qubit as target:
$\frac{1}{\sqrt{2}}(\ket{000} + \ket{111})$
5. This is the GHZ state
1.6 PROBLEM 6
Alice prepares a qubit in the state $\ket{\psi} = \alpha\ket{0} + \beta\ket{1}$ and sends it to
Bob. Bob performs a measurement in the $\{\ket{+}, \ket{-}\}$ basis, where $\ket{\pm} =
\frac{1}{\sqrt{2}}(\ket{0} \pm \ket{1})$. What is the probability that Bob measures
$\ket{+}$?
Solution:
1. The probability is given by $|\bra{+}\psi\rangle|^2$
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
2. $\bra{+}\psi\rangle = \frac{1}{\sqrt{2}}(\alpha + \beta)$
3. Therefore, the probability is |1
β2(πΌ + π½)|2=1
2|πΌ + π½|2
1.7 PROBLEM 7
Calculate the quantum channel capacity of the amplitude damping channel with damping
parameter πΎ = 0.2.
Solution:
1. The quantum capacity of the amplitude damping channel is given by: π(β°)=
max0β€πβ€1[π»2(π)β π»2((1 β πΎ)π)] where π»2(π₯)= βπ₯log2(π₯)β(1 β π₯)log2(1 β π₯) is the
binary entropy function
2. We need to find the maximum of this function numerically
3. Using numerical optimization, we find that the maximum occurs at π β 0.7589
4. The quantum capacity is approximately 0.5596 qubits per channel use
1.8 PROBLEM 8
Implement Groverβs algorithm to search for a marked item in a database of 8 items. How many
iterations of Groverβs operator are needed?
Solution:
1. For N items, the optimal number of iterations is approximately π
4βπ
2. In this case, π = 8
3. Number of iterations βπ
4β8 β 2.22
4. Rounding to the nearest integer, we need 2 iterations of Groverβs operator
1.9 PROBLEM 9
Alice and Bob want to perform quantum key distribution using the BB84 protocol. They
exchange 1000 qubits, and in the sifting phase, they find that 500 of their basis choices
matched. After error correction and privacy amplification, they end up with a 100-bit secure
key. What was their quantum bit error rate (QBER)?
Solution:
1. In BB84, half of the matching basis choices are used for error estimation
2. So, 250 bits are used for error estimation, and 250 bits for the raw key
3. The final key is 100 bits, so 150 bits were removed during error correction and privacy
amplification
4. Assuming the bits removed are roughly equal to the number of errors, the QBER is
approximately: ππ΅πΈπ
β 150
250 = 0.6 or 60%
1.10 PROBLEM 10
A quantum computer is using the surface code for error correction. If the physical qubit error
rate is 10β3 and we want a logical error rate of 10β15, how many physical qubits are needed
per logical qubit?
Solution:
1. The logical error rate in the surface code scales as ππΏβ(π/ππ‘β)π/2, where π is the
physical error rate, ππ‘β is the threshold (around 1%), and π is the code distance
2. We want 10β15 β(10β3/10β2)π/2 = 0.1π/2
3. Solving this, we get π β 30
4. In the surface code, the number of physical qubits per logical qubit is approximately 2π2
5. Therefore, we need approximately 2 β 302=1800 physical qubits per logical qubit
