ibm_Fidelity.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Do the necessary imports\n",
    "import numpy as np\n",
    "from numpy import sqrt, exp, zeros, where\n",
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute\n",
    "from qiskit import IBMQ, Aer, transpile, assemble\n",
    "from qiskit.visualization import plot_histogram, plot_bloch_multivector, array_to_latex\n",
    "from qiskit.extensions import Initialize\n",
    "from qiskit.ignis.verification import marginal_counts\n",
    "from qiskit.quantum_info import random_statevector, state_fidelity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_bell_pair(qc, a, b):\n",
    "    \"\"\"Creates a bell pair in qc using qubits a & b\"\"\"\n",
    "    qc.h(a) # Put qubit a into state |+>\n",
    "    qc.cx(a,b) # CNOT with a as control and b as target\n",
    "    \n",
    "def node1_gates(qc, psi, a):\n",
    "    qc.cx(psi, a)\n",
    "    qc.h(psi)\n",
    "\n",
    "def measure_and_send(qc, a, b):\n",
    "    \"\"\"Measures qubits a & b and 'sends' the results to node2\"\"\"\n",
    "    qc.barrier()\n",
    "    qc.measure(a,0)\n",
    "    qc.measure(b,1)\n",
    "    \n",
    "# This function takes a QuantumCircuit (qc), integer (qubit)\n",
    "# and ClassicalRegisters (crz & crx) to decide which gates to apply\n",
    "def node2_gates(qc, qubit, crz, crx):\n",
    "    # Here we use c_if to control our gates with a classical\n",
    "    # bit instead of a qubit\n",
    "    qc.x(qubit).c_if(crx, 1) # Apply gates if the registers \n",
    "    qc.z(qubit).c_if(crz, 1) # are in the state '1'\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [],
   "source": [
    "def send_state(state1,state2,node1,node2):\n",
    "    ## Set 1-qubit state\n",
    "    # psi = [1/sqrt(2), -1/sqrt(2)]\n",
    "    psi = state1\n",
    "    init_gate = Initialize(psi)\n",
    "    init_gate.label = \"init\"\n",
    "\n",
    "    ## SETUP\n",
    "    # Protocol uses 3 qubits and 2 classical bits in 2 different registers\n",
    "    qr = QuantumRegister(3, name=\"q\")\n",
    "    crz, crx = ClassicalRegister(1, name=\"crz\"), ClassicalRegister(1, name=\"crx\")\n",
    "    teleportation_circuit = QuantumCircuit(qr, crz, crx)\n",
    "\n",
    "    ## STEP 0\n",
    "    # # First, let's initialize Alice's q0\n",
    "    teleportation_circuit.append(init_gate, [0])\n",
    "    teleportation_circuit.barrier()\n",
    "\n",
    "    ## STEP 1\n",
    "    create_bell_pair(teleportation_circuit, 1, 2)\n",
    "\n",
    "    ## STEP 2\n",
    "    teleportation_circuit.barrier() # Use barrier to separate steps\n",
    "    node1_gates(teleportation_circuit, 0, 1) \n",
    "\n",
    "    ## STEP 3\n",
    "    measure_and_send(teleportation_circuit, 0, 1)\n",
    "\n",
    "    ## STEP 4\n",
    "    teleportation_circuit.barrier() # Use barrier to separate steps\n",
    "    node2_gates(teleportation_circuit, 2, crz, crx)\n",
    "    # teleportation_circuit.draw()\n",
    "\n",
    "    backend = Aer.get_backend('aer_simulator')\n",
    "    teleportation_circuit.save_statevector()   # Tell simulator to save statevector\n",
    "    qobj = assemble(teleportation_circuit)     # Create a Qobj from the circuit for the simulator to run\n",
    "    result = backend.run(qobj).result() # Do the simulation and return the result\n",
    "    out_state = result.get_statevector()\n",
    "\n",
    "    state1 = []\n",
    "    parte1=np.asarray(out_state[0:4])\n",
    "    parte2=np.asarray(out_state[4:8])\n",
    "    \n",
    "    \n",
    "    state1= [max(parte1.min(), parte1.max(),key=abs), max(parte2.min(), parte2.max(),key=abs)]\n",
    "    \n",
    "    fidelity=state_fidelity(state1,state2,validate=True)\n",
    "    if node1 == node2:\n",
    "        fidelity = 0\n",
    "    # state2 = [1/sqrt(2), 1/sqrt(2)]\n",
    "    return fidelity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4999999999999999"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "esta1 = [0, -1]\n",
    "esta2 = [1, 0]\n",
    "state2 = [1/sqrt(2), -1/sqrt(2)]\n",
    "\n",
    "send_state(esta1,state2,1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.7493994566546427e-33"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Prueba función send_state\n",
    "\n",
    "state1 = [1/sqrt(2), 1/sqrt(2)]\n",
    "state2 = [1/sqrt(2), -1/sqrt(2)]\n",
    "state4 = [0, -1]\n",
    "state3 = [1, 0]\n",
    "state5 = [20/sqrt(401), 1/sqrt(401)]\n",
    "\n",
    "\n",
    "\n",
    "send_state(state1,state2,1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fidelity_table(state,current_node,number_nodes):\n",
    "    fid_block= list(zeros(number_nodes))\n",
    "    for i in range(number_nodes):\n",
    "        fid_block[i] = send_state(state[i],state[current_node-1],i,current_node)\n",
    "    return fid_block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3.7493994566546427e-33,\n",
       " 0.9999999999999996,\n",
       " 0,\n",
       " 0.4999999999999999,\n",
       " 0.45012468827930163]"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# nodes=[1,2,3,4,5]\n",
    "statesss = [state1,state2,state3,state4,state5]\n",
    "# for i range(5):\n",
    "fidelity_table(statesss,2,5)\n",
    "# len(statesss)"
   ]
  }
 ],
 "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.7.4"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}