diff --git a/community/paper_implementation_project/b92/b92_implementation.ipynb b/community/paper_implementation_project/b92/b92_implementation.ipynb new file mode 100644 index 000000000..5828fc1c5 --- /dev/null +++ b/community/paper_implementation_project/b92/b92_implementation.ipynb @@ -0,0 +1,395 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# **B92 Quantum Key Distribution Protocol**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Overview of the B92 Quantum Key Distribution Protocol**\n", + "\n", + "The B92 protocol enables two parties—**Alice** and **Bob**—to securely share a secret key using quantum states. It uses **two non-orthogonal states** to detect potential eavesdropping and ensure confidentiality.\n", + "\n", + "### **Step 1: Key Preparation and Transmission**\n", + "\n", + "- **Alice** generates a random bit string.\n", + "- She encodes each bit as:\n", + " - `0` → ∣0⟩ \n", + " - `1` → ∣+⟩ = $\\frac{1}{\\sqrt{2}}$(∣0⟩ + ∣1⟩) \n", + "- The qubits are sent to **Bob** over a quantum channel.\n", + "\n", + "### **Step 2: Measurement and Filtering**\n", + "\n", + "- **Bob** randomly chooses a basis to measure each qubit:\n", + " - Basis 0: detects ∣1⟩ → infers bit 0 \n", + " - Basis 1: detects ∣−⟩ → infers bit 1 \n", + "- Only **conclusive** results are kept; inconclusive ones are discarded.\n", + "\n", + "### **Step 3: Sifting and Error Checking**\n", + "\n", + "- Alice and Bob use a public channel to identify positions with conclusive results and extract the **raw key**.\n", + "- They compare a random sample of bits to estimate the error rate.\n", + "- If the error rate is too high, the protocol is aborted (possible eavesdropping).\n", + "\n", + "### **Step 4: Key Refinement**\n", + "\n", + "- If the error rate is acceptable:\n", + " - **Error correction** aligns their keys.\n", + " - **Privacy amplification** (e.g., parity hashing) shortens and strengthens the key.\n", + "- The final output is a shared, secure secret key." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Code Implementation**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from classiq import *\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# B92 uses only two non-orthogonal states: |0⟩ for bit 0, |+⟩ for bit 1.\n", + "\n", + "@qfunc\n", + "def b92(message: CArray[CBool], bob_bases: CArray[CBool], qba: QArray[QBit]) -> None:\n", + " \"\"\"\n", + " Implements the quantum part of B92 protocol.\n", + " \"\"\"\n", + " # Alice encodes: 0 -> |0⟩, 1 -> |+⟩\n", + " repeat(message.len,\n", + " lambda i:\n", + " if_(message[i]==1,\n", + " lambda: H(qba[i])\n", + " )\n", + " )\n", + " \n", + " # Bob applies measurement: \n", + " # He tries to detect in the state orthogonal to Alice's states.\n", + " # If Alice sends |0⟩, Bob measures in {|1⟩} basis => Apply X before measurement.\n", + " # If Alice sends |+⟩, Bob measures in {|−⟩} basis => Apply H, then X.\n", + "\n", + " repeat(bob_bases.len,\n", + " lambda i:\n", + " if_(bob_bases[i]==0,\n", + " lambda: X(qba[i]) # Measure in {|1⟩}\n", + " ,\n", + " lambda:\n", + " (H(qba[i]), X(qba[i])) # Measure in {|−⟩}\n", + " )\n", + " )\n", + "\n", + "# Number of qubits\n", + "SIZE = 8\n", + "\n", + "np.random.seed(3)\n", + "# Alice's message: random bits {0,1}\n", + "message = np.random.randint(0, 2, SIZE).tolist()\n", + "# Bob's measurement choice: randomly pick which orthogonal basis to measure in\n", + "bob_bases = np.random.randint(0, 2, SIZE).tolist()\n", + "\n", + "\n", + "@qfunc\n", + "def main(qba: Output[QArray[QBit]]) -> None:\n", + " \"\"\"\n", + " B92 protocol quantum function.\n", + " \"\"\"\n", + " allocate(SIZE, qba)\n", + " b92(message, bob_bases, qba)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# ===============================\n", + "# Quantum Model Creation\n", + "# ===============================\n", + "# Create a quantum model from the main function\n", + "qmod = create_model(main, out_file=\"b92_implementation\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# ===============================\n", + "# Set Execution Preferences\n", + "# ===============================\n", + "from classiq.execution import ExecutionPreferences\n", + "\n", + "execution_preferences = ExecutionPreferences(\n", + " num_shots=2048\n", + ")\n", + "\n", + "qmod = set_execution_preferences(qmod, execution_preferences)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# ===============================\n", + "# Circuit Synthesis and Execution\n", + "# ===============================\n", + "# Synthesize the quantum circuit to an executable form\n", + "qprog = synthesize(qmod)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quantum program link: https://platform.classiq.io/circuit/2z2TV4paNkuZmahkRgT8x8mudzn\n" + ] + } + ], + "source": [ + "# Visualize the generated quantum circuit\n", + "show(qprog)" + ] + }, + { + "attachments": { + "2ywUZTB2gFXH7PDerI72rrMH7GO.jpg": { + "image/jpeg": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![2ywUZTB2gFXH7PDerI72rrMH7GO.jpg](attachment:2ywUZTB2gFXH7PDerI72rrMH7GO.jpg)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "job = execute(qprog)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# ===============================\n", + "# Results Processing\n", + "# ===============================\n", + "results = job.get_sample_result().parsed_counts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Post-Measurement Steps in B92 Protocol**\n", + "\n", + "Once Bob measures the qubits, the protocol continues with classical post-processing:\n", + "\n", + "### **1. State Announcement**\n", + "\n", + "- **Bob** announces the positions where he got conclusive measurements.\n", + "- **Alice** confirms which of those are valid (i.e., match the expected encoding).\n", + "- Only unambiguous results are kept for key generation.\n", + "\n", + "### **2. Raw Key Sifting**\n", + "\n", + "- Alice and Bob retain bits only from positions with conclusive results.\n", + "- These bits form the **raw key**.\n", + "\n", + "### **3. Error Estimation**\n", + "\n", + "- They compare a random subset of the raw key to estimate the **error rate**.\n", + "- A low error rate suggests the channel was secure.\n", + "- If the error rate is too high, the key is discarded and the protocol is restarted.\n", + "\n", + "### **4. Error Correction**\n", + "\n", + "- In practice, error-correcting codes are used to reconcile any remaining mismatches.\n", + "- In this simulation, we assume perfect correction for simplicity.\n", + "\n", + "### **5. Privacy Amplification**\n", + "\n", + "- A hash function is applied to the corrected key to shorten it and eliminate any partial knowledge an eavesdropper may have.\n", + "- The result is the final **secure shared key**.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "def complete_b92_protocol(measurements_list, alice_message=None, bob_bases=None):\n", + " \"\"\"\n", + " Post-processing for the B92 protocol: extract key from measurements.\n", + "\n", + " Args:\n", + " measurements_list: List of SampledState objects from Classiq\n", + " alice_message: Optional[List[int]] – Alice's original message bits\n", + " bob_bases: Optional[List[int]] – Bob's chosen measurement bases\n", + " Returns:\n", + " Dict containing Alice/Bob keys, error rate, and final secure key\n", + " \"\"\"\n", + "\n", + " # Constants\n", + " SIZE = len(measurements_list[0].state['qba'])\n", + "\n", + " # Generate or validate Alice's message and Bob's bases\n", + " alice_message = alice_message or np.random.randint(0, 2, SIZE).tolist()\n", + " bob_bases = bob_bases or np.random.randint(0, 2, SIZE).tolist()\n", + " if len(alice_message) != SIZE or len(bob_bases) != SIZE:\n", + " raise ValueError(\"alice_message and bob_bases must be of length SIZE\")\n", + "\n", + " # Extract Bob's measurement with highest shots\n", + " try:\n", + " best_measurement = max(measurements_list, key=lambda m: m.shots)\n", + " bob_measurements = best_measurement.state['qba']\n", + " except Exception:\n", + " try:\n", + " bob_measurements = measurements_list[0].state['qba']\n", + " except Exception:\n", + " raise ValueError(\"Failed to extract measurements from SampledState objects\")\n", + "\n", + " if not isinstance(bob_measurements, list) or len(bob_measurements) != SIZE:\n", + " raise ValueError(\"Invalid measurement result\")\n", + "\n", + " # Filter conclusive results\n", + " conclusive_indices = [i for i in range(SIZE) if bob_measurements[i] == 1]\n", + " conclusive_alice = [alice_message[i] for i in conclusive_indices]\n", + " conclusive_bob = [0 if bob_bases[i] == 0 else 1 for i in conclusive_indices]\n", + "\n", + " # Error estimation\n", + " errors = sum(a != b for a, b in zip(conclusive_alice, conclusive_bob))\n", + " total = len(conclusive_indices)\n", + " error_rate = errors / total if total else 1.0\n", + "\n", + " result = {\n", + " \"alice_raw_key\": conclusive_alice,\n", + " \"bob_raw_key\": conclusive_bob,\n", + " \"error_rate\": error_rate,\n", + " \"final_key\": None\n", + " }\n", + "\n", + " if not total:\n", + " return result # No conclusive results\n", + "\n", + " if error_rate < 0.15:\n", + " # Error correction: keep only matching bits\n", + " corrected_key = [a for a, b in zip(conclusive_alice, conclusive_bob) if a == b]\n", + "\n", + " # Privacy amplification: simple parity hash\n", + " final_key = [corrected_key[i] ^ corrected_key[i+1] for i in range(0, len(corrected_key)-1, 2)]\n", + " result[\"final_key\"] = final_key\n", + " else:\n", + " # High error rate implies possible eavesdropping\n", + " result[\"final_key\"] = None\n", + "\n", + " return result" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Final B92 Protocol Results:\n", + "{'alice_raw_key': [0, 0, 0, 1, 1, 0], 'bob_raw_key': [0, 0, 0, 0, 0, 1], 'error_rate': 0.5, 'final_key': None}\n" + ] + } + ], + "source": [ + "# ===============================\n", + "# Run the complete B92 protocol\n", + "# ===============================\n", + "b92_results = complete_b92_protocol(list(results))\n", + "\n", + "print(\"\\nFinal B92 Protocol Results:\")\n", + "print(b92_results)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **References**\n", + "\n", + "**Note:** References [2]–[6] provide foundational background on quantum cryptography and the B92 protocol but were not all directly used in this specific implementation.\n", + "\n", + "[1] **Experimental Realization of Three Quantum Key Distribution Protocols** \n", + "[Online]. Available: [https://www.researchgate.net/publication/337670669_Experimental_Realization_of_Three_Quantum_Key_Distribution_Protocols](https://www.researchgate.net/publication/337670669_Experimental_Realization_of_Three_Quantum_Key_Distribution_Protocols)\n", + "\n", + "[2] C. H. Bennett, \"Quantum cryptography using any two nonorthogonal states,\" *Physical Review Letters*, vol. 68, no. 21, pp. 3121–3124, 1992.\n", + "\n", + "[3] M. Nielsen and I. Chuang, *Quantum Computation and Quantum Information*, Cambridge University Press, 2000.\n", + "\n", + "[4] N. Gisin, G. Ribordy, W. Tittel, and H. Zbinden, \"Quantum cryptography,\" *Rev. Mod. Phys.*, vol. 74, no. 1, pp. 145–195, 2002.\n", + "\n", + "[5] V. Scarani, A. Acín, G. Ribordy, and N. Gisin, \"Quantum cryptography protocols robust against photon number splitting attacks for weak laser pulse implementations,\" *Physical Review Letters*, vol. 92, no. 5, p. 057901, 2004.\n", + "\n", + "[6] S. Pirandola, U. L. Andersen, L. Banchi, et al., \"Advances in quantum cryptography,\" *Advances in Optics and Photonics*, vol. 12, no. 4, pp. 1012–1236, 2020.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/community/paper_implementation_project/b92/b92_implementation.metadata.json b/community/paper_implementation_project/b92/b92_implementation.metadata.json new file mode 100644 index 000000000..a303e7baf --- /dev/null +++ b/community/paper_implementation_project/b92/b92_implementation.metadata.json @@ -0,0 +1,7 @@ +{ + "friendly_name": "B92 protocol", + "description": "B92 Quantum Key Distribution Protocol for secure key generation using two non-orthogonal quantum states", + "qmod_type": ["algorithms"], + "problem_domain_tags": [], + "level": ["basic", "demos"] +} diff --git a/community/paper_implementation_project/b92/b92_implementation.qmod b/community/paper_implementation_project/b92/b92_implementation.qmod new file mode 100644 index 000000000..dfd66ab13 --- /dev/null +++ b/community/paper_implementation_project/b92/b92_implementation.qmod @@ -0,0 +1,20 @@ +qfunc b92(message: bool[], bob_bases: bool[], qba: qbit[]) { + repeat (i: message.len) { + if (message[i] == 1) { + H(qba[i]); + } + } + repeat (i: bob_bases.len) { + if (bob_bases[i] == 0) { + X(qba[i]); + } else { + H(qba[i]); + X(qba[i]); + } + } +} + +qfunc main(output qba: qbit[]) { + allocate(8, qba); + b92([0, 0, 1, 1, 0, 0, 0, 1], [1, 1, 0, 1, 1, 1, 0, 1], qba); +} diff --git a/community/paper_implementation_project/b92/b92_implementation.synthesis_options.json b/community/paper_implementation_project/b92/b92_implementation.synthesis_options.json new file mode 100644 index 000000000..4035390d9 --- /dev/null +++ b/community/paper_implementation_project/b92/b92_implementation.synthesis_options.json @@ -0,0 +1,46 @@ +{ + "constraints": { + "max_gate_count": {}, + "optimization_parameter": "no_opt" + }, + "preferences": { + "machine_precision": 8, + "custom_hardware_settings": { + "basis_gates": [ + "cx", + "sx", + "r", + "u1", + "u", + "cz", + "rx", + "rz", + "id", + "ry", + "cy", + "y", + "x", + "u2", + "z", + "sdg", + "h", + "tdg", + "s", + "p", + "sxdg", + "t" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "synthesize_all_separately": false, + "optimization_level": 3, + "output_format": [ + "qasm" + ], + "pretty_qasm": true, + "transpilation_option": "auto optimize", + "timeout_seconds": 300, + "random_seed": 1735422602 + } +} \ No newline at end of file