Sign Flip Code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 Qubit sign flip code\n",
    "## In this code we make the assumption that the error happens in one part of the circuit. And also, the error only affects one qubit at a time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First, let's define some function that will be useful for later.  The first two functions transform a string to bits and vice versa. The get_noise applies a x gate on a random qubit if a probability check up is met and finally codificate which codificate a bit string into its equivalent in qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, QuantumRegister, Aer, execute, ClassicalRegister\n",
    "from qiskit.ignis.verification.topological_codes import RepetitionCode\n",
    "from qiskit.ignis.verification.topological_codes import lookuptable_decoding\n",
    "from qiskit.ignis.verification.topological_codes import GraphDecoder\n",
    "from qiskit.providers.aer.noise import NoiseModel\n",
    "from qiskit.providers.aer.noise.errors import pauli_error, depolarizing_error\n",
    "from qiskit.ignis.mitigation.measurement import (complete_meas_cal,CompleteMeasFitter)\n",
    "from qiskit.visualization import plot_histogram\n",
    "import random\n",
    "backend = Aer.get_backend('qasm_simulator')\n",
    "#These two functions were taken from https://stackoverflow.com/questions/10237926/convert-string-to-list-of-bits-and-viceversa\n",
    "\n",
    "def tobits(s):\n",
    "    result = []\n",
    "    for c in s:\n",
    "        bits = bin(ord(c))[2:]\n",
    "        bits = '00000000'[len(bits):] + bits\n",
    "        result.extend([int(b) for b in bits])\n",
    "    return ''.join([str(x) for x in result])\n",
    "\n",
    "def frombits(bits):\n",
    "    chars = []\n",
    "    for b in range(int(len(bits) / 8)):\n",
    "        byte = bits[b*8:(b+1)*8]\n",
    "        chars.append(chr(int(''.join([str(bit) for bit in byte]), 2)))\n",
    "    return ''.join(chars)\n",
    "\n",
    "def get_noise(circuit,probability,qubits):\n",
    "    random_number = random.uniform(0, 1)\n",
    "    if(random_number <= probability):\n",
    "        qubit = random.randint(0,len(qubits)-1)\n",
    "        circuit.z(qubit)\n",
    "    return circuit\n",
    "\n",
    "def codificate(bitString):\n",
    "    qubits = list()\n",
    "    for i in range(len(bitString)):\n",
    "        mycircuit = QuantumCircuit(1,1)\n",
    "        if(bitString[i] == \"1\"):\n",
    "            mycircuit.x(0)\n",
    "        mycircuit.h(0)\n",
    "        qubits.append(mycircuit)\n",
    "    return qubits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's see the result for the string without any noise on the circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I like dogs\n"
     ]
    }
   ],
   "source": [
    "m0 = tobits(\"I like dogs\") \n",
    "qubits = codificate(m0)\n",
    "measurements = list()\n",
    "for i in range(len(qubits)):\n",
    "    qubit = qubits[i]\n",
    "    qubit.h(0)\n",
    "    qubit.measure(0,0)\n",
    "    result = execute(qubit, backend, shots=1, memory=True).result()\n",
    "    measurements.append(int(result.get_memory()[0]))\n",
    "print(frombits(measurements))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next, if we add some noise then the result will be the following"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I*È{jm â'\u0007{\n"
     ]
    }
   ],
   "source": [
    "m0 = tobits(\"I like dogs\") \n",
    "qubits = codificate(m0)\n",
    "measurements = list()\n",
    "for i in range(len(qubits)):\n",
    "    qubit = qubits[i]\n",
    "    qubit = get_noise(qubit,0.2,range(qubit.num_qubits))\n",
    "    qubit.h(0)\n",
    "    qubit.measure(0,0)    \n",
    "    result = execute(qubit, backend, shots=1, memory=True).result()\n",
    "    measurements.append(int(result.get_memory()[0]))\n",
    "print(frombits(measurements))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next we apply the circuit for the error correction. It consists of four additional qubits that check if one qubit had changed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(qubits)):\n",
    "    cb = QuantumRegister(1,'code_qubit')\n",
    "    lq = QuantumRegister(4,'ancilla_qubit')\n",
    "    sb = ClassicalRegister(2,'syndrome_bit')\n",
    "    out = ClassicalRegister(1,'output_bit')\n",
    "    mycircuit = QuantumCircuit(cb,lq,sb,out)\n",
    "    if(m0[i] == \"1\"):\n",
    "        mycircuit.x(0)\n",
    "    qubit.h(0)\n",
    "    mycircuit.cx(0,1)\n",
    "    mycircuit.cx(1,2)\n",
    "    mycircuit.h([0,1,2])\n",
    "    mycircuit.barrier()\n",
    "    mycircuit = get_noise(mycircuit,0.2,range(3))\n",
    "    mycircuit.barrier()\n",
    "    mycircuit.h([0,1,2])\n",
    "    mycircuit.cx(0,3)\n",
    "    mycircuit.cx(1,3)\n",
    "    mycircuit.cx(0,4)\n",
    "    mycircuit.cx(2,4)\n",
    "    mycircuit.measure(3,0)\n",
    "    mycircuit.measure(4,1)\n",
    "    qubits[i] = mycircuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Finally, we check with the help of the four qubits if something had changed and then we apply a correction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "without error correction the string was: I mik= tg's\n",
      "with error correction the string was: I like dogs\n"
     ]
    }
   ],
   "source": [
    "measurements = list()\n",
    "raw_bits = list()\n",
    "for i in range(len(qubits)):\n",
    "    qubit = qubits[i]\n",
    "    qubit.measure(0,2)\n",
    "    result = execute(qubit, backend, shots=1, memory=True).result()\n",
    "    bits = result.get_memory()[0]\n",
    "    raw_bits.append(int(bits[0]))\n",
    "for i in range(len(qubits)):\n",
    "    qubit = qubits[i]\n",
    "    result = execute(qubit, backend, shots=1, memory=True).result()\n",
    "    bits = result.get_memory()[0]\n",
    "    if(bits[2] == '1' and bits[3] == '0'):\n",
    "        qubit.x(2)\n",
    "    if(bits[2] == '0' and bits[3] == '1'):\n",
    "        qubit.x(1)\n",
    "    if(bits[2] == '1' and bits[3] == '1'):\n",
    "        qubit.x(0)\n",
    "    qubit.measure(0,2)\n",
    "    result = execute(qubit, backend, shots=1, memory=True).result()\n",
    "    bits = result.get_memory()[0]\n",
    "    measurements.append(int(bits[0]))\n",
    "print(\"without error correction the string was: \" + frombits(raw_bits))\n",
    "print(\"with error correction the string was: \" + frombits(measurements))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References:\n",
    "Devitt, Simon & Munro, William & Nemoto, Kae. (2013). Quantum Error Correction for Beginners. Reports on progress in physics. Physical Society (Great Britain). 76. 076001. 10.1088/0034-4885/76/7/076001. \n",
    "\n",
    "https://en.wikipedia.org/wiki/Quantum_error_correction#The_sign_flip_code"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}