Added E91 QKD Implementation

Covers the implementation of E91 QKD, for a predefined num_bits = 2000.

Author: sricharan2901

quantum/e91.py

@@ -0,0 +1,175 @@
+
+"""
+Implements the E91 quantum key distribution (QKD) protocol.
+This protocol uses the principles of quantum entanglement and the violation of
+Bell's inequality to securely distribute a secret key
+between two parties (Alice and Bob) and to detect
+the presence of an eavesdropper (Eve).
+
+How it works:
+1.  A source (Charlie) generates pairs of entangled qubits in a Bell
+    state and sends one qubit of each pair to Alice and the other to Bob.
+2.  Alice and Bob each independently and randomly choose to measure their
+    incoming qubits in one of three predefined measurement bases.
+3.  After all measurements are complete, they communicate over a public
+    channel to compare the bases they chose for each qubit.
+4.  They divide their measurement results into two sets:
+    a) Cases where their chosen bases were "compatible" are used to
+       generate a secret key. Due to entanglement, their results in these
+       cases should be perfectly correlated.
+    b) Cases where their bases were "incompatible" are used to test for
+       eavesdropping by calculating the CHSH inequality parameter 'S'.
+5.  Quantum mechanics predicts that for an entangled system, |S| can reach
+    2*sqrt(2) (~2.828), whereas any classical (or eavesdropped) system is
+    bound by |S| <= 2. If their calculated S-value significantly violates
+    the classical bound, they can be confident that no eavesdropping
+    occurred and their generated key is secure.
+"""
+
+import numpy as np
+import qiskit
+import random
+from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
+from qiskit_aer import AerSimulator
+
+
+def e91_protocol(n_bits: int = 2000) -> dict:
+    """
+    Simulates the E91 QKD protocol for a specified number of bits.
+
+    Args:
+        n_bits: The total number of entangled pairs to be generated and
+                measured. This determines the potential length of the raw key.
+
+    Returns:
+        A dictionary containing the simulation results:
+        - "alice_key": Alice's final, sifted secret key.
+        - "bob_key": Bob's final, sifted secret key.
+        - "s_value": The calculated CHSH inequality parameter 'S'.
+        - "eavesdropper_detected": A boolean indicating if |S| <= 2.
+        - "key_match": A boolean indicating if Alice's and Bob's keys match.
+        - "key_length": The final length of the sifted keys.
+    """
+
+    if not isinstance(n_bits, int):
+        raise TypeError("Number of bits must be an integer.")
+    if n_bits <= 0:
+        raise ValueError("Number of bits must be > 0.")
+    if n_bits > 10000:
+        raise ValueError("Number of bits is too large to simulate efficiently.")
+
+    # Define the measurement angles for Alice and Bob's bases.
+    # The keys correspond to the basis name, and values are angles in radians.
+    alice_bases = {'A1': 0, 'A2': np.pi / 8, 'A3': np.pi / 4}
+    bob_bases = {'B1': np.pi / 8, 'B2': np.pi / 4, 'B3': 3 * np.pi / 8}
+
+    # Lists to store the choices and results for each bit.
+    alice_chosen_bases, bob_chosen_bases = [], []
+    alice_results, bob_results = [], []
+
+    # Get the quantum simulator backend.
+    backend = AerSimulator()
+
+    for _ in range(n_bits):
+        # Alice and Bob randomly choose their measurement bases.
+        alice_basis_name = random.choice(list(alice_bases.keys()))
+        bob_basis_name = random.choice(list(bob_bases.keys()))
+        alice_angle = alice_bases[alice_basis_name]
+        bob_angle = bob_bases[bob_basis_name]
+
+        # Create a quantum circuit for one entangled pair.
+        qr = QuantumRegister(2, 'q')
+        cr = ClassicalRegister(2, 'c')
+        circuit = QuantumCircuit(qr, cr)
+
+        # Create a Bell state |Φ+⟩ = (|00⟩ + |11⟩)/sqrt(2)
+        circuit.h(qr[0])
+        circuit.cx(qr[0], qr[1])
+
+        # Apply rotations to simulate measurements in the chosen bases.
+        # We use RY gates, which rotate around the Y-axis of the Bloch sphere.
+        circuit.ry(-2 * alice_angle, qr[0])
+        circuit.ry(-2 * bob_angle, qr[1])
+
+        # Measure the qubits.
+        circuit.measure(qr, cr)
+
+        # Execute the circuit and get the result.
+        job = backend.run(circuit, shots=1)
+        result = list(job.result().get_counts().keys())[0]
+
+        # Store choices and results. Qiskit's bit order is reversed.
+        alice_chosen_bases.append(alice_basis_name)
+        bob_chosen_bases.append(bob_basis_name)
+        alice_results.append(int(result[1]))
+        bob_results.append(int(result[0]))
+
+    # Sift for generating the secret key.
+    # The key is formed when Alice and Bob choose compatible bases.
+    alice_key, bob_key = [], []
+    for i in range(n_bits):
+        is_A2B1 = alice_chosen_bases[i] == 'A2' and bob_chosen_bases[i] == 'B1'
+        is_A3B2 = alice_chosen_bases[i] == 'A3' and bob_chosen_bases[i] == 'B2'
+        if is_A2B1 or is_A3B2:
+            alice_key.append(alice_results[i])
+            bob_key.append(bob_results[i])
+
+    # Sift for the CHSH inequality test (Eve detection).
+    # We use four specific combinations of bases for the test: a = A1, a' = A3  |  b = B1, b' = B3
+    chsh_correlations = {'ab': [], 'ab_': [], 'a_b': [], 'a_b_': []}
+
+    for i in range(n_bits):
+        a_val = 1 if alice_results[i] == 0 else -1
+        b_val = 1 if bob_results[i] == 0 else -1
+        product = a_val * b_val  # +1 if correlated, -1 if anti-correlated
+
+        alice_basis = alice_chosen_bases[i]
+        bob_basis = bob_chosen_bases[i]
+
+        if alice_basis == 'A1' and bob_basis == 'B1':
+            chsh_correlations['ab'].append(product)
+        elif alice_basis == 'A1' and bob_basis == 'B3':
+            chsh_correlations['ab_'].append(product)
+        elif alice_basis == 'A3' and bob_basis == 'B1':
+            chsh_correlations['a_b'].append(product)
+        elif alice_basis == 'A3' and bob_basis == 'B3':
+            chsh_correlations['a_b_'].append(product)
+
+    # Calculate the expectation value (average correlation) for each combination.
+    E = {}
+    for key, values in chsh_correlations.items():
+        E[key] = np.mean(values) if values else 0
+
+    # Calculate the S-value: S = E(a,b) - E(a,b') + E(a',b) + E(a',b')
+    s_value = E['ab'] - E['ab_'] + E['a_b'] + E['a_b_']
+
+    # Check for eavesdropper: |S| > 2 indicates security.
+    eavesdropper_detected = abs(s_value) <= 2
+
+    return {
+        "alice_key": "".join(map(str, alice_key)),
+        "bob_key": "".join(map(str, bob_key)),
+        "s_value": s_value,
+        "eavesdropper_detected": eavesdropper_detected,
+        "key_match": alice_key == bob_key,
+        "key_length": len(alice_key)
+    }
+
+
+if __name__ == "__main__":
+    # num_bits is initialized to 2000
+    num_bits = 2000
+    results = e91_protocol(num_bits)
+
+    print(f"Total bits simulated: {num_bits}")
+    print(f"CHSH S-value: {results['s_value']:.4f}")
+    print(f"Eavesdropper detected: {results['eavesdropper_detected']}")
+    print(f"Final key length: {results['key_length']}")
+    print(f"Keys match: {results['key_match']}")
+
+    if not results['eavesdropper_detected'] and results['key_match'] and results['key_length'] > 0:
+        print("\nProtocol successful! Secret key generated securely.")
+        print(f"  Alice's key: {results['alice_key']}")
+        print(f"  Bob's key:   {results['bob_key']}")
+    else:
+        print("\nProtocol failed or eavesdropper detected. Key discarded.")