Quantum_Key_Dist.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "526532cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, Aer, transpile\n",
    "from qiskit.visualization import plot_histogram, plot_bloch_multivector\n",
    "from numpy.random import randint\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "15341a6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Genera una serie di circuiti per creare una sequenza di qubit nello stato (0 1 + -) a secondo del bit e della base\n",
    "def codifica_messaggio(bits, basi):\n",
    "    messaggio = []\n",
    "    for i in range(n):\n",
    "        qc = QuantumCircuit(1,1)\n",
    "        if basi[i] == 0: # Prepara il qubit in base Z\n",
    "            if bits[i] == 0:\n",
    "                pass \n",
    "            else:\n",
    "                qc.x(0)\n",
    "        else: # Prepara il qubit in base X\n",
    "            if bits[i] == 0:\n",
    "                qc.h(0)\n",
    "            else:\n",
    "                qc.x(0)\n",
    "                qc.h(0)\n",
    "        qc.barrier()\n",
    "        messaggio.append(qc)\n",
    "    return messaggio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "7ea12a8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def misura_messaggio(messaggio, basi):\n",
    "    backend = Aer.get_backend('aer_simulator')\n",
    "    misurazioni = []\n",
    "    for q in range (n):\n",
    "        if basi[q] == 0: # misura in base z\n",
    "            messaggio[q].measure(0,0)\n",
    "        if basi[q] == 1: # misura in base X\n",
    "            messaggio[q].h(0)\n",
    "            messaggio[q].measure(0,0)\n",
    "        aer_sim = Aer.get_backend('aer_simulator')\n",
    "        result = aer_sim.run(messaggio[q], shot=1, memory=True).result()\n",
    "        misura_bit = int(result.get_memory()[0])\n",
    "        misurazioni.append(misura_bit)\n",
    "    return misurazioni"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "6d43450c",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Se Bob ha misurato un bit nella stessa base in cui lo ha preparato Alice, significa che il valore in bob_misura\n",
    "corrisponderà al valore in alice_bits e possono usare quel bit come parte della loro chiave.\n",
    "Se hanno misurato su basi diverse, il risultato di Bob è casuale ed entrambi buttano via quel bit.\n",
    "\n",
    "Ecco una funzione rimozione_differenze che fa questo.\n",
    "'''\n",
    "def rimozione_differenze(a_basi, b_basi, bits):\n",
    "    bit_buoni = []\n",
    "    for q in range(n):\n",
    "        if a_basi[q] == b_basi[q]:\n",
    "            bit_buoni.append(bits[q])\n",
    "    return bit_buoni"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "ed26b373",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Questa funzione ritorna un array di bit selezionati dalla chiave, togliendoli dalla stessa.\n",
    "\n",
    "# np.mod(a,b) calcola il resto della divisione a/b\n",
    "# v = arr.pop(i) rimuove l'elemento iesimo dall'array arr e lo copia in v \n",
    "\n",
    "def selezione_bits(bits, selezione):\n",
    "    selezionati = []\n",
    "    for i in selezione:\n",
    "        # con np.mod si fa in modo che i non vada fuori range\n",
    "        i = np.mod(i, len(bits))\n",
    "        selezionati.append(bits.pop(i))\n",
    "    return selezionati"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "f7850922",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice bits  [1 1 0 0 1 1 1 1 1 0]\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(seed = 1)\n",
    "n = 10\n",
    "\n",
    "## Step 1\n",
    "# Alice genera un array di n bit\n",
    "alice_bits = randint(2, size = n)\n",
    "print('Alice bits ', alice_bits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "5af3d679",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice basi: Z X Z X X Z Z X Z Z \n",
      "\n",
      "Circuiti relativi a ogni qubit\n",
      "\n",
      "Qubit 0 - valore 1 - base Z\n",
      "     ┌───┐ ░ \n",
      "q_0: ┤ X ├─░─\n",
      "     └───┘ ░ \n",
      "c: 1/════════\n",
      "             \n",
      "\n",
      "Qubit 1 - valore 1 - base X\n",
      "     ┌───┐┌───┐ ░ \n",
      "q_0: ┤ X ├┤ H ├─░─\n",
      "     └───┘└───┘ ░ \n",
      "c: 1/═════════════\n",
      "                  \n",
      "\n",
      "Qubit 2 - valore 0 - base Z\n",
      "      ░ \n",
      "q_0: ─░─\n",
      "      ░ \n",
      "c: 1/═══\n",
      "        \n",
      "\n",
      "Qubit 3 - valore 0 - base X\n",
      "     ┌───┐ ░ \n",
      "q_0: ┤ H ├─░─\n",
      "     └───┘ ░ \n",
      "c: 1/════════\n",
      "             \n",
      "\n",
      "Qubit 4 - valore 1 - base X\n",
      "     ┌───┐┌───┐ ░ \n",
      "q_0: ┤ X ├┤ H ├─░─\n",
      "     └───┘└───┘ ░ \n",
      "c: 1/═════════════\n",
      "                  \n",
      "\n",
      "Qubit 5 - valore 1 - base Z\n",
      "     ┌───┐ ░ \n",
      "q_0: ┤ X ├─░─\n",
      "     └───┘ ░ \n",
      "c: 1/════════\n",
      "             \n",
      "\n",
      "Qubit 6 - valore 1 - base Z\n",
      "     ┌───┐ ░ \n",
      "q_0: ┤ X ├─░─\n",
      "     └───┘ ░ \n",
      "c: 1/════════\n",
      "             \n",
      "\n",
      "Qubit 7 - valore 1 - base X\n",
      "     ┌───┐┌───┐ ░ \n",
      "q_0: ┤ X ├┤ H ├─░─\n",
      "     └───┘└───┘ ░ \n",
      "c: 1/═════════════\n",
      "                  \n",
      "\n",
      "Qubit 8 - valore 1 - base Z\n",
      "     ┌───┐ ░ \n",
      "q_0: ┤ X ├─░─\n",
      "     └───┘ ░ \n",
      "c: 1/════════\n",
      "             \n",
      "\n",
      "Qubit 9 - valore 0 - base Z\n",
      "      ░ \n",
      "q_0: ─░─\n",
      "      ░ \n",
      "c: 1/═══\n",
      "        \n",
      "\n"
     ]
    }
   ],
   "source": [
    "## Step 2\n",
    "# Alice crea un array di basi di misura (0 = Z ; 1 = X)\n",
    "alice_basi = randint(2, size = n)\n",
    "\n",
    "# Stampa Alice basi\n",
    "print('Alice basi:', end = ' ')\n",
    "for i in range(n):\n",
    "    if alice_basi[i] == 0:\n",
    "        print('Z', end = ' ')\n",
    "    else:\n",
    "        print('X', end = ' ')\n",
    "        \n",
    "# Crea messaggio tramite la funzione definita 'codifica_messaggio'\n",
    "messaggio = codifica_messaggio(alice_bits, alice_basi)\n",
    "\n",
    "# Stampa i circuiti relativi a ogni qubit\n",
    "print()\n",
    "print()\n",
    "print('Circuiti relativi a ogni qubit')\n",
    "print()\n",
    "for i in range(n):\n",
    "    print('Qubit', i, '- valore', alice_bits[i], '- base', end = ' ')\n",
    "    \n",
    "    if alice_basi[i] == 0:\n",
    "        print('Z')\n",
    "    else:\n",
    "        print('X')\n",
    "    \n",
    "    print(messaggio[i])\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "ecf8c5f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice basi:                                       Z X Z X X Z Z X Z Z \n",
      "Bob basi:                                         Z X Z Z X Z Z Z X Z \n",
      "\n",
      "Alice bits:                                       1 1 0 0 1 1 1 1 1 0 \n",
      "Bob misura il messaggio di Alice con le sue basi: 1 1 0 0 1 1 1 0 0 0 "
     ]
    }
   ],
   "source": [
    "## Step 3\n",
    "# Bob genera una sequenza di basi\n",
    "bob_basi = randint(2, size = n)\n",
    "\n",
    "# Stampa Alice basi\n",
    "print('Alice basi:                                      ', end = ' ')\n",
    "for i in range(n):\n",
    "    if alice_basi[i] == 0:\n",
    "        print('Z', end = ' ')\n",
    "    else:\n",
    "        print('X', end = ' ')\n",
    "\n",
    "print()\n",
    "        \n",
    "# Stampa basi di Bob\n",
    "print('Bob basi:                                        ', end = ' ')\n",
    "for i in range(n):\n",
    "    if bob_basi[i] == 0:\n",
    "        print('Z', end = ' ')\n",
    "    else:\n",
    "        print('X', end = ' ')\n",
    "print()\n",
    "print()\n",
    "print('Alice bits:                                       ', end = '')\n",
    "for i in alice_bits:\n",
    "    print(i, end = ' ')\n",
    "print()\n",
    "\n",
    "# Bob misura il messaggio di Alice con le sue basi\n",
    "bob_misura = misura_messaggio(messaggio, bob_basi)\n",
    "\n",
    "print('Bob misura il messaggio di Alice con le sue basi: ', end = '')\n",
    "for i in bob_misura:\n",
    "    print(i, end = ' ')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "cb6688ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 0, 1, 1, 1, 0]\n",
      "[1, 1, 0, 1, 1, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "# Alice e Bob scartano entrambi i bit inutili e usano i bit rimanenti per formare le loro chiavi segrete:\n",
    "\n",
    "## Step 4\n",
    "alice_chiave = rimozione_differenze(alice_basi, bob_basi, alice_bits)\n",
    "bob_chiave = rimozione_differenze(alice_basi, bob_basi, bob_misura)\n",
    "print(alice_chiave)\n",
    "print(bob_chiave)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "3477c0da",
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.mod(a,b) calcola il resto della divisione a/b\n",
    "# v = arr.pop(i) rimuove l'elemento iesimo dall'array arr e lo copia in v "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "e7893768",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  bob_test = [0, 1, 1, 0]\n",
      "alice_test = [0, 1, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "## Step 5\n",
    "# randint(a, size=n) genera un array di n numeri random compresi tra 0 e a-1\n",
    "lung_selezione = 4\n",
    "bit_selezionati = randint(n, size=lung_selezione)\n",
    "\n",
    "bob_test = selezione_bits(bob_chiave, bit_selezionati)\n",
    "print(\"  bob_test = \" + str(bob_test))\n",
    "alice_test = selezione_bits(alice_chiave, bit_selezionati)\n",
    "print(\"alice_test = \"+ str(alice_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "5cf76012",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** Test chiavi coincidenti ***\n",
      "Alice chiave: [1, 1, 1]\n",
      "Bob chiave:   [1, 1, 1]\n",
      "lunghezza chiave = 3\n"
     ]
    }
   ],
   "source": [
    "if bob_test == alice_test:\n",
    "    print('*** Test chiavi coincidenti ***')\n",
    "else:\n",
    "    print('--- Test chiavi non coincidenti ---')\n",
    "    \n",
    "print('Alice chiave:', alice_chiave)\n",
    "print('Bob chiave:  ', bob_chiave)\n",
    "print(\"lunghezza chiave = %i\" % len(alice_chiave))"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}