Steane_Code_logical_operation_software_decoding_with_noise_and_without_transpilation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Steane code logical operation with software decoding\n",
    "============================================\n",
    "\n",
    "In this workbook logical operations for the Steane code are compared with the equivalent operations for a single qubit.  The workbook is set up without transpilation and iterates through a number of scaling error factors.\n",
    "\n",
    "1. Set up logical zero for Steane code based  on the parity matrix in the book by Nielsen MA, Chuang IL. Quantum Computation and Quantum Information, 10th Anniversary Edition. Cambridge University Press; 2016. p. 474 \n",
    "\n",
    "2. Set up physical Hadamard, CX and X to produce a physical Bell pair.\n",
    "\n",
    "2. Set up logical Hadamard, CX and X to produce a logical Bell pair.\n",
    "\n",
    "3. Set up the ancilla for the logical qubits\n",
    "\n",
    "4. Attempt to correct the logical data qubits using decoding software.\n",
    "\n",
    "5. Assess how many data qubits would give a valid logical Bell state and compare to the physical qubits.\n",
    "\n",
    "6. Repeat for different noise scaling factors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import the necessary function modules, including the SteaneCodeLogicalQubit class and helper functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import(\n",
    "    QuantumCircuit,\n",
    "    QuantumRegister,\n",
    "    ClassicalRegister,\n",
    "    execute,\n",
    "    Aer\n",
    "    )\n",
    "\n",
    "from qiskit.providers.aer.noise import NoiseModel\n",
    "from qiskit.providers.aer.noise.errors import pauli_error, depolarizing_error\n",
    "from qiskit.compiler import transpile\n",
    "\n",
    "from circuits import SteaneCodeLogicalQubit\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from datetime import datetime\n",
    "\n",
    "from helper_functions import (\n",
    "    count_valid_output_strings,\n",
    "    find_individual_ancilla_values,\n",
    "    find_ancilla_values,\n",
    "    find_parity,\n",
    "    get_noise,\n",
    "    summarise_logical_counts,\n",
    "    mean_of_list,\n",
    "    calculate_standard_error,\n",
    "    flip_code_words, \n",
    "    correct_qubit,\n",
    "    convert_codewords,\n",
    "    look_up_data,\n",
    "    print_time,\n",
    "    get_parity_check_matrix,\n",
    "    get_codewords\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define constants so that the process flow can be controlled from one place:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_QUBITS = 7\n",
    "ANCILLA_QUBITS = 3\n",
    "SPACE = ' '\n",
    "FACTOR_LIST = [1, 0.1, 0.01, 0.001, 0.0001]\n",
    "TITLE1 = 'Bell pair fidelity in logical and physical qubits '\n",
    "\n",
    "#use standard gate set without transpilation\n",
    "SINGLE_GATE_SET  = ['id', 'x', 'y', 'z', 'h']\n",
    "TWO_GATE_SET = ['cx', 'cz']\n",
    "\n",
    "NOISE = True                            #Test with noise\n",
    "SHOTS = 100000                          #Number of shots to run    \n",
    "MEASURE_NOISE = 0.0046                  #Measurement noise\n",
    "SINGLE_GATE_DEPOLARISING = 0.000366     #Single gate noise   \n",
    "TWO_GATE_DEPOLARISING = 0.022           #Two gate noise \n",
    "ITERATIONS = 25\n",
    "\n",
    "SIMULATOR = Aer.get_backend('qasm_simulator')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Specify the parity check matrix, since this defines the Steane code.  It is validated before the logical qubit is initiated to check that it is orthogonal to the valid codewords."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['0001111', '0110011', '1010101']\n"
     ]
    }
   ],
   "source": [
    "parity_check_matrix = get_parity_check_matrix()\n",
    "print(parity_check_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The allowed codewords for the logical zero from Nielsen and Chuang is stored in a list.  Note, the order of qubits in the list is reversed compared to the normal output of Qiskit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['0000000', '1010101', '0110011', '1100110', '0001111', '1011010', '0111100', '1101001']\n"
     ]
    }
   ],
   "source": [
    "codewords = get_codewords()\n",
    "print(codewords)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#carryout a bit flip of the list of codewords to find the codewords for the logical one.\n",
    "flipped_codewords = flip_code_words(codewords)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#The allowed codewords for a single qubit Bell pair\n",
    "bell_valid_codewords = ['01','10']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Physical qubits circuit for Bell pair\n",
    "-------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function module to set up a Bell pair with two physical qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def execute_physical_qubits(measure_noise, single_gate_depolarising, two_gate_depolarising):\n",
    "    print()\n",
    "    print('Physical qubits Bell pair')\n",
    "    error_rate_list = []\n",
    "    for iteration in range(ITERATIONS):\n",
    "        #print(f'For iteration {iteration}')\n",
    "        qr = QuantumRegister(2,'code_qubit')     # Two code QBits\n",
    "        cr = ClassicalRegister(2,'syndrome_bit') # Two registers\n",
    "        qc = QuantumCircuit(qr, cr)\n",
    "        qc.h(qr[0])\n",
    "        qc.x(qr[1])\n",
    "        qc.cx(qr[0],qr[1])\n",
    "        qc.measure(qr, cr)\n",
    "        #initialise circuit\n",
    "        if NOISE:\n",
    "            noise_model = get_noise(measure_noise, single_gate_depolarising, \n",
    "                                    two_gate_depolarising, SINGLE_GATE_SET , TWO_GATE_SET\n",
    "                                   )\n",
    "        if NOISE:\n",
    "            result = execute(qc, SIMULATOR, noise_model = noise_model, shots = SHOTS).result()\n",
    "        else:\n",
    "            result = execute(qc, SIMULATOR, shots = SHOTS).result()\n",
    "        counts = result.get_counts(qc)\n",
    "        count_valid, count_invalid, _ = count_valid_output_strings(counts, bell_valid_codewords, 0)\n",
    "        #print(f'The results are {counts}')\n",
    "        #print(f'Valid codewords {bell_valid_codewords}')      \n",
    "        error_rate = count_invalid / SHOTS\n",
    "        #print(f'The error rate is {error_rate:.4f}')\n",
    "        #print()\n",
    "        error_rate_list.append(error_rate)\n",
    "    mean_error_physical = mean_of_list(error_rate_list)\n",
    "    standard_deviation_physical, standard_error_physical = calculate_standard_error(error_rate_list)\n",
    "    print(f'The mean error rate is {mean_error_physical:.8f} and the standard error is {standard_error_physical:.8f}')\n",
    "    return(mean_error_physical, standard_error_physical)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical Bell pair\n",
    "-----------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function module to set up the Bell pair with two logical qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_up_circuit():\n",
    "    qubit = SteaneCodeLogicalQubit(2, parity_check_matrix, codewords)\n",
    "    for index in range(2):\n",
    "        qubit.set_up_logical_zero(index)\n",
    "    qubit.barrier()\n",
    "    qubit.logical_gate_H(0)\n",
    "    qubit.logical_gate_X(1)    \n",
    "    qubit.logical_gate_CX(0, 1)\n",
    "    qubit.barrier()\n",
    "    for index in range(2):\n",
    "        qubit.set_up_ancilla(index)\n",
    "        qubit.barrier()\n",
    "        qubit.logical_measure_data(index)\n",
    "        qubit.logical_measure_ancilla(index)\n",
    "    return(qubit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function module to execute the logical Bell pair.  For items in the counts dictionary the data qubits are corrected based on the ancilla measurements.  Each data qubit measurements is then decoded to:\n",
    " - 0 if the bit string is in the set of logical zero bitstring\n",
    " - 1 if the bit string is in the set of logical one bitstring\n",
    " - 2 if the bitstring is outside the codespace of valid bitstrings\n",
    "\n",
    "A check is made to find out if the string of two bits after decoding is in the set of valid bell pairs {'01' and '10'}\n",
    "Finally the results of the calculation are summarised and returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def execute_logical_qubits(measure_noise, single_gate_depolarising, two_gate_depolarising):\n",
    "    print()\n",
    "    print('Logical qubits Bell pair')\n",
    "    corrected_key =''\n",
    "    invalid_list = []\n",
    "    valid_list = []\n",
    "    for iteration in range(ITERATIONS):\n",
    "        corrected_counts = {}\n",
    "        new_counts = {}\n",
    "        qubit = set_up_circuit()\n",
    "        if NOISE:\n",
    "                noise_model = get_noise(measure_noise, single_gate_depolarising, \n",
    "                                        two_gate_depolarising, SINGLE_GATE_SET , TWO_GATE_SET\n",
    "                                       )\n",
    "                result = execute(qubit, SIMULATOR, noise_model = noise_model, shots = SHOTS).result()\n",
    "        else:\n",
    "                result = execute(qubit, SIMULATOR, shots = SHOTS).result()\n",
    "        counts = result.get_counts(qubit)\n",
    "        corrected_data = []\n",
    "        for key, values in counts.items():\n",
    "            #print('key, values', key, values)\n",
    "            # Z ancilla2\n",
    "            key0 = key.split()[0]\n",
    "            # X ancilla2\n",
    "            key1 = key.split()[1]\n",
    "            #data qubits2\n",
    "            key2 = key.split()[2]\n",
    "            # Z ancilla1\n",
    "            key3 = key.split()[3]\n",
    "            # X ancilla1\n",
    "            key4 = key.split()[4]\n",
    "            #data qubits1\n",
    "            key5 = key.split()[5]           \n",
    "            corrected_data0 = correct_qubit(key2, key0, DATA_QUBITS)\n",
    "            corrected_data1 = correct_qubit(key5, key3, DATA_QUBITS)\n",
    "            corrected_key = key0 + SPACE + key1 + SPACE + corrected_data0 + SPACE\n",
    "            corrected_key = corrected_key + key3 + SPACE + key4 + SPACE + corrected_data1\n",
    "            value_found = corrected_counts.get(corrected_key)\n",
    "            if value_found:\n",
    "                corrected_counts[corrected_key] = value_found + values\n",
    "            else:\n",
    "                corrected_counts.update({corrected_key: values})  \n",
    "        new_counts = summarise_logical_counts(corrected_counts, codewords, flipped_codewords, 2, 5)  \n",
    "        count_valid, count_invalid, _ = count_valid_output_strings(new_counts, bell_valid_codewords, 0)\n",
    "        invalid_list.append(count_invalid)\n",
    "        valid_list.append(count_valid)\n",
    "    mean_invalid = mean_of_list(invalid_list)\n",
    "    total_valid = sum(valid_list)\n",
    "    total_invalid = sum(invalid_list)\n",
    "    total_all = total_valid + total_invalid\n",
    "    print(f'There were {total_valid} valid shots and {total_invalid} invalid shots giving {total_all} in total')\n",
    "    mean_error_logical = mean_invalid / SHOTS\n",
    "    standard_deviation, standard_error = calculate_standard_error(invalid_list)\n",
    "    standard_error_logical = standard_error / SHOTS\n",
    "    print(f'On average there are {mean_invalid:.1f} invalid codewords with a standard error of {standard_error:.1f}')\n",
    "    print(f'The mean error rate for a single qubit is {mean_error_logical :.8f} and the standard error is {standard_error_logical:.8f}')\n",
    "    return(mean_error_logical, standard_error_logical)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function for plotting graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_graph(title, factor_list, physical_list, logical_list, physical_error_list, logical_error_list):\n",
    "    plt.plot(factor_list, physical_list, '.',color = '#ff8333',linestyle = '', label = 'Physical Qubits')\n",
    "    plt.plot(factor_list, logical_list, '.',color = '#8333ff', linestyle = '',label = 'Logical Qubits')\n",
    "    plt.errorbar(factor_list, physical_list, yerr = physical_error_list, color = '#ff8333' )\n",
    "    plt.errorbar(factor_list, logical_list, yerr = logical_error_list, color = '#8333ff' )\n",
    "    plt.xlabel('Error scaling factor')\n",
    "    plt.ylabel('Error rate')\n",
    "    plt.title(title, fontsize = '8')\n",
    "    plt.xscale(\"log\")\n",
    "    plt.yscale(\"log\")\n",
    "    plt.legend(fontsize = '8')\n",
    "    fname = '/.graphs/' + title + '.png'\n",
    "    plt.savefig(title)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iterate through different noise scaling factor for physical and logical Bell pairs and append results to lists used for graphs.  The different noise scenarios are considered in turn because the simulations might take a long time to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running with normal noise\n",
      "\n",
      "Processing error scaling factor 1\n",
      "Current Time = 15:11:48\n",
      "\n",
      "Physical qubits Bell pair\n",
      "The mean error rate is 0.03064720 and the standard error is 0.00010487\n",
      "\n",
      "Logical qubits Bell pair\n",
      "There were 1125601 valid shots and 1374399 invalid shots giving 2500000 in total\n",
      "On average there are 54976.0 invalid codewords with a standard error of 38.0\n",
      "The mean error rate for a single qubit is 0.54975960 and the standard error is 0.00037976\n",
      "\n",
      "Processing error scaling factor 0.1\n",
      "Current Time = 15:25:29\n",
      "\n",
      "Physical qubits Bell pair\n",
      "The mean error rate is 0.00312720 and the standard error is 0.00003386\n",
      "\n",
      "Logical qubits Bell pair\n",
      "There were 2323070 valid shots and 176930 invalid shots giving 2500000 in total\n",
      "On average there are 7077.2 invalid codewords with a standard error of 21.6\n",
      "The mean error rate for a single qubit is 0.07077200 and the standard error is 0.00021555\n",
      "\n",
      "Processing error scaling factor 0.01\n",
      "Current Time = 15:38:51\n",
      "\n",
      "Physical qubits Bell pair\n",
      "The mean error rate is 0.00031440 and the standard error is 0.00001218\n",
      "\n",
      "Logical qubits Bell pair\n",
      "There were 2482026 valid shots and 17974 invalid shots giving 2500000 in total\n",
      "On average there are 719.0 invalid codewords with a standard error of 4.9\n",
      "The mean error rate for a single qubit is 0.00718960 and the standard error is 0.00004865\n",
      "\n",
      "Processing error scaling factor 0.001\n",
      "Current Time = 15:52:26\n",
      "\n",
      "Physical qubits Bell pair\n",
      "The mean error rate is 0.00002600 and the standard error is 0.00000346\n",
      "\n",
      "Logical qubits Bell pair\n",
      "There were 2498186 valid shots and 1814 invalid shots giving 2500000 in total\n",
      "On average there are 72.6 invalid codewords with a standard error of 1.9\n",
      "The mean error rate for a single qubit is 0.00072560 and the standard error is 0.00001874\n",
      "\n",
      "Processing error scaling factor 0.0001\n",
      "Current Time = 16:06:10\n",
      "\n",
      "Physical qubits Bell pair\n",
      "The mean error rate is 0.00000320 and the standard error is 0.00000111\n",
      "\n",
      "Logical qubits Bell pair\n",
      "There were 2499818 valid shots and 182 invalid shots giving 2500000 in total\n",
      "On average there are 7.3 invalid codewords with a standard error of 0.5\n",
      "The mean error rate for a single qubit is 0.00007280 and the standard error is 0.00000531\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "physical_list = []\n",
    "logical_list = []\n",
    "physical_error_list = []\n",
    "logical_error_list = []\n",
    "title2 = 'with normal noise'\n",
    "print('Running with normal noise')\n",
    "for factor in FACTOR_LIST:\n",
    "    print()\n",
    "    print(f'Processing error scaling factor {factor}')\n",
    "    print_time()\n",
    "    measure_noise = MEASURE_NOISE * factor\n",
    "    single_gate_depolarising = SINGLE_GATE_DEPOLARISING * factor\n",
    "    two_gate_depolarising = TWO_GATE_DEPOLARISING * factor\n",
    "    \n",
    "    mean_error, standard_error = execute_physical_qubits(measure_noise, single_gate_depolarising, two_gate_depolarising)\n",
    "    physical_list.append(mean_error)\n",
    "    physical_error_list.append(standard_error)\n",
    "    \n",
    "    mean_error, standard_error = execute_logical_qubits(measure_noise, single_gate_depolarising, two_gate_depolarising)\n",
    "    logical_list.append(mean_error)\n",
    "    logical_error_list.append(standard_error)\n",
    "title = TITLE1 + title2\n",
    "plot_graph(title, FACTOR_LIST, physical_list, logical_list, physical_error_list, logical_error_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running without measure noise\n",
      "Processing error scaling factor 1\n",
      "Current Time = 16:19:40\n",
      "\n",
      "Physical qubits Bell pair\n",
      "The mean error rate is 0.02210520 and the standard error is 0.00008188\n",
      "\n",
      "Logical qubits Bell pair\n",
      "There were 1228729 valid shots and 1271271 invalid shots giving 2500000 in total\n",
      "On average there are 50850.8 invalid codewords with a standard error of 30.0\n",
      "The mean error rate for a single qubit is 0.50850840 and the standard error is 0.00029986\n",
      "Processing error scaling factor 0.1\n",
      "Current Time = 16:33:09\n",
      "\n",
      "Physical qubits Bell pair\n",
      "The mean error rate is 0.00218040 and the standard error is 0.00002553\n",
      "\n",
      "Logical qubits Bell pair\n",
      "There were 2344002 valid shots and 155998 invalid shots giving 2500000 in total\n",
      "On average there are 6239.9 invalid codewords with a standard error of 15.8\n",
      "The mean error rate for a single qubit is 0.06239920 and the standard error is 0.00015787\n",
      "Processing error scaling factor 0.01\n",
      "Current Time = 16:46:40\n",
      "\n",
      "Physical qubits Bell pair\n",
      "The mean error rate is 0.00022200 and the standard error is 0.00001095\n",
      "\n",
      "Logical qubits Bell pair\n",
      "There were 2484347 valid shots and 15653 invalid shots giving 2500000 in total\n",
      "On average there are 626.1 invalid codewords with a standard error of 4.9\n",
      "The mean error rate for a single qubit is 0.00626120 and the standard error is 0.00004946\n",
      "Processing error scaling factor 0.001\n",
      "Current Time = 17:00:11\n",
      "\n",
      "Physical qubits Bell pair\n",
      "The mean error rate is 0.00002160 and the standard error is 0.00000206\n",
      "\n",
      "Logical qubits Bell pair\n",
      "There were 2498441 valid shots and 1559 invalid shots giving 2500000 in total\n",
      "On average there are 62.4 invalid codewords with a standard error of 1.6\n",
      "The mean error rate for a single qubit is 0.00062360 and the standard error is 0.00001598\n",
      "Processing error scaling factor 0.0001\n",
      "Current Time = 17:13:21\n",
      "\n",
      "Physical qubits Bell pair\n",
      "The mean error rate is 0.00000200 and the standard error is 0.00000082\n",
      "\n",
      "Logical qubits Bell pair\n",
      "There were 2499857 valid shots and 143 invalid shots giving 2500000 in total\n",
      "On average there are 5.7 invalid codewords with a standard error of 0.4\n",
      "The mean error rate for a single qubit is 0.00005720 and the standard error is 0.00000414\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "physical_list = []\n",
    "logical_list = []\n",
    "physical_error_list = []\n",
    "logical_error_list = []\n",
    "title2 = 'with no measure noise'\n",
    "print('Running without measure noise')\n",
    "for factor in FACTOR_LIST:\n",
    "    print(f'Processing error scaling factor {factor}')\n",
    "    print_time()\n",
    "    measure_noise = 0\n",
    "    single_gate_depolarising = SINGLE_GATE_DEPOLARISING * factor\n",
    "    two_gate_depolarising = TWO_GATE_DEPOLARISING * factor\n",
    "    \n",
    "    mean_error, standard_error = execute_physical_qubits(measure_noise, single_gate_depolarising, two_gate_depolarising)\n",
    "    physical_list.append(mean_error)\n",
    "    physical_error_list.append(standard_error)\n",
    "    \n",
    "    mean_error, standard_error = execute_logical_qubits(measure_noise, single_gate_depolarising, two_gate_depolarising)\n",
    "    logical_list.append(mean_error)\n",
    "    logical_error_list.append(standard_error)\n",
    "title = TITLE1 + title2\n",
    "plot_graph(title, FACTOR_LIST, physical_list, logical_list, physical_error_list, logical_error_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running with single and two gate noises same\n",
      "Processing error scaling factor 1\n",
      "Current Time = 17:26:32\n",
      "\n",
      "Physical qubits Bell pair\n",
      "The mean error rate is 0.02200600 and the standard error is 0.00010175\n",
      "\n",
      "Logical qubits Bell pair\n",
      "There were 1228809 valid shots and 1271191 invalid shots giving 2500000 in total\n",
      "On average there are 50847.6 invalid codewords with a standard error of 37.3\n",
      "The mean error rate for a single qubit is 0.50847640 and the standard error is 0.00037291\n",
      "Processing error scaling factor 0.1\n",
      "Current Time = 17:40:08\n",
      "\n",
      "Physical qubits Bell pair\n",
      "The mean error rate is 0.00217200 and the standard error is 0.00003285\n",
      "\n",
      "Logical qubits Bell pair\n",
      "There were 2343605 valid shots and 156395 invalid shots giving 2500000 in total\n",
      "On average there are 6255.8 invalid codewords with a standard error of 18.0\n",
      "The mean error rate for a single qubit is 0.06255800 and the standard error is 0.00017988\n",
      "Processing error scaling factor 0.01\n",
      "Current Time = 17:54:02\n",
      "\n",
      "Physical qubits Bell pair\n",
      "The mean error rate is 0.00024080 and the standard error is 0.00001281\n",
      "\n",
      "Logical qubits Bell pair\n",
      "There were 2484089 valid shots and 15911 invalid shots giving 2500000 in total\n",
      "On average there are 636.4 invalid codewords with a standard error of 3.7\n",
      "The mean error rate for a single qubit is 0.00636440 and the standard error is 0.00003650\n",
      "Processing error scaling factor 0.001\n",
      "Current Time = 18:07:40\n",
      "\n",
      "Physical qubits Bell pair\n",
      "The mean error rate is 0.00001880 and the standard error is 0.00000273\n",
      "\n",
      "Logical qubits Bell pair\n",
      "There were 2498492 valid shots and 1508 invalid shots giving 2500000 in total\n",
      "On average there are 60.3 invalid codewords with a standard error of 1.4\n",
      "The mean error rate for a single qubit is 0.00060320 and the standard error is 0.00001391\n",
      "Processing error scaling factor 0.0001\n",
      "Current Time = 18:20:58\n",
      "\n",
      "Physical qubits Bell pair\n",
      "The mean error rate is 0.00000200 and the standard error is 0.00000100\n",
      "\n",
      "Logical qubits Bell pair\n",
      "There were 2499843 valid shots and 157 invalid shots giving 2500000 in total\n",
      "On average there are 6.3 invalid codewords with a standard error of 0.4\n",
      "The mean error rate for a single qubit is 0.00006280 and the standard error is 0.00000398\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "physical_list = []\n",
    "logical_list = []\n",
    "physical_error_list = []\n",
    "logical_error_list = []\n",
    "title2 = 'with same single and two gate noise'\n",
    "print('Running with single and two gate noises same')\n",
    "for factor in FACTOR_LIST:\n",
    "    print(f'Processing error scaling factor {factor}')\n",
    "    print_time()\n",
    "    measure_noise = 0\n",
    "    single_gate_depolarising = SINGLE_GATE_DEPOLARISING * factor\n",
    "    two_gate_depolarising = TWO_GATE_DEPOLARISING * factor\n",
    "    \n",
    "    mean_error, standard_error = execute_physical_qubits(measure_noise, single_gate_depolarising, two_gate_depolarising)\n",
    "    physical_list.append(mean_error)\n",
    "    physical_error_list.append(standard_error)\n",
    "    \n",
    "    mean_error, standard_error = execute_logical_qubits(measure_noise, single_gate_depolarising, two_gate_depolarising)\n",
    "    logical_list.append(mean_error)\n",
    "    logical_error_list.append(standard_error)\n",
    "title = TITLE1 + title2\n",
    "plot_graph(title, FACTOR_LIST, physical_list, logical_list, physical_error_list, logical_error_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "bce8fa9fbc203f16ab824739bfe2fff4e777c5492be5e63b66d9b944743a7909"
  },
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}