mirror of
https://github.com/TheAlgorithms/Python.git
synced 2024-11-27 15:01:08 +00:00
d764eec655
* Fix failing pytest quantum/bb84.py * Update bb84.py test results to match current qiskit
134 lines
4.1 KiB
Python
134 lines
4.1 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Simulation of the Quantum Key Distribution (QKD) protocol called BB84,
|
|
created by Charles Bennett and Gilles Brassard in 1984.
|
|
|
|
BB84 is a key-distribution protocol that ensures secure key distribution
|
|
using qubits instead of classical bits. The generated key is the result
|
|
of simulating a quantum circuit. Our algorithm to construct the circuit
|
|
is as follows:
|
|
|
|
Alice generates two binary strings. One encodes the basis for each qubit:
|
|
|
|
- 0 -> {0,1} basis.
|
|
- 1 -> {+,-} basis.
|
|
|
|
The other encodes the state:
|
|
|
|
- 0 -> |0> or |+>.
|
|
- 1 -> |1> or |->.
|
|
|
|
Bob also generates a binary string and uses the same convention to choose
|
|
a basis for measurement. Based on the following results, we follow the
|
|
algorithm below:
|
|
|
|
X|0> = |1>
|
|
|
|
H|0> = |+>
|
|
|
|
HX|0> = |->
|
|
|
|
1. Whenever Alice wants to encode 1 in a qubit, she applies an
|
|
X (NOT) gate to the qubit. To encode 0, no action is needed.
|
|
|
|
2. Wherever she wants to encode it in the {+,-} basis, she applies
|
|
an H (Hadamard) gate. No action is necessary to encode a qubit in
|
|
the {0,1} basis.
|
|
|
|
3. She then sends the qubits to Bob (symbolically represented in
|
|
this circuit using wires).
|
|
|
|
4. Bob measures the qubits according to his binary string for
|
|
measurement. To measure a qubit in the {+,-} basis, he applies
|
|
an H gate to the corresponding qubit and then performs a measurement.
|
|
|
|
References:
|
|
https://en.wikipedia.org/wiki/BB84
|
|
https://qiskit.org/textbook/ch-algorithms/quantum-key-distribution.html
|
|
"""
|
|
import numpy as np
|
|
import qiskit
|
|
|
|
|
|
def bb84(key_len: int = 8, seed: int | None = None) -> str:
|
|
"""
|
|
Performs the BB84 protocol using a key made of `key_len` bits.
|
|
The two parties in the key distribution are called Alice and Bob.
|
|
Args:
|
|
key_len: The length of the generated key in bits. The default is 8.
|
|
|
|
seed: Seed for the random number generator.
|
|
Mostly used for testing. Default is None.
|
|
|
|
Returns:
|
|
key: The key generated using BB84 protocol.
|
|
|
|
>>> bb84(16, seed=0)
|
|
'0111110111010010'
|
|
|
|
>>> bb84(8, seed=0)
|
|
'10110001'
|
|
"""
|
|
# Set up the random number generator.
|
|
rng = np.random.default_rng(seed=seed)
|
|
|
|
# Roughly 25% of the qubits will contribute to the key.
|
|
# So we take more than we need.
|
|
num_qubits = 6 * key_len
|
|
# Measurement basis for Alice's qubits.
|
|
alice_basis = rng.integers(2, size=num_qubits)
|
|
# The set of states Alice will prepare.
|
|
alice_state = rng.integers(2, size=num_qubits)
|
|
# Measurement basis for Bob's qubits.
|
|
bob_basis = rng.integers(2, size=num_qubits)
|
|
|
|
# Quantum Circuit to simulate BB84
|
|
bb84_circ = qiskit.QuantumCircuit(num_qubits, name="BB84")
|
|
|
|
# Alice prepares her qubits according to rules above.
|
|
for index, _ in enumerate(alice_basis):
|
|
if alice_state[index] == 1:
|
|
bb84_circ.x(index)
|
|
if alice_basis[index] == 1:
|
|
bb84_circ.h(index)
|
|
bb84_circ.barrier()
|
|
|
|
# Bob measures the received qubits according to rules above.
|
|
for index, _ in enumerate(bob_basis):
|
|
if bob_basis[index] == 1:
|
|
bb84_circ.h(index)
|
|
|
|
bb84_circ.barrier()
|
|
bb84_circ.measure_all()
|
|
|
|
# Simulate the quantum circuit.
|
|
sim = qiskit.Aer.get_backend("aer_simulator")
|
|
# We only need to run one shot because the key is unique.
|
|
# Multiple shots will produce the same key.
|
|
job = qiskit.execute(bb84_circ, sim, shots=1, seed_simulator=seed)
|
|
# Returns the result of measurement.
|
|
result = job.result().get_counts(bb84_circ).most_frequent()
|
|
|
|
# Extracting the generated key from the simulation results.
|
|
# Only keep measurement results where Alice and Bob chose the same basis.
|
|
gen_key = "".join(
|
|
[
|
|
result_bit
|
|
for alice_basis_bit, bob_basis_bit, result_bit in zip(
|
|
alice_basis, bob_basis, result
|
|
)
|
|
if alice_basis_bit == bob_basis_bit
|
|
]
|
|
)
|
|
|
|
# Get final key. Pad with 0 if too short, otherwise truncate.
|
|
key = gen_key[:key_len] if len(gen_key) >= key_len else gen_key.ljust(key_len, "0")
|
|
return key
|
|
|
|
|
|
if __name__ == "__main__":
|
|
print(f"The generated key is : {bb84(8, seed=0)}")
|
|
from doctest import testmod
|
|
|
|
testmod()
|