Steane_code_FT_encoding.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Steane code encoding fault tolerance\n",
    "=============================== \n",
    "\n",
    "1. Set up two 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 fault tolerance as per scheme B, C and D from Goto H. Minimizing resource overheads for fault-tolerant preparation of encoded states of the Steane code. Sci Rep. 2016 Jan 27;6:19578. \n",
    "\n",
    "3. Compare this with the non fault tolerant encoding circuit and a single qubit.\n",
    "\n",
    "3. Find out if either scheme have a tolerance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import the necessary function modules, including the SteaneCodeLogicalQubit class.  The methods of this class are called in this notebook."
   ]
  },
  {
   "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",
    "\n",
    "from circuits import SteaneCodeLogicalQubit\n",
    "\n",
    "from helper_functions import (\n",
    "    get_noise, \n",
    "    mean_of_list,\n",
    "    calculate_standard_error,\n",
    "    print_time,\n",
    "    process_FT_results\n",
    "    )\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define constants so the process flow can be controlled from one place:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "SINGLE_GATE_ERRORS = ['x', 'y', 'z', 'h', 's', 'sdg']\n",
    "TWO_GATE_ERRORS = ['cx', 'cz']\n",
    "\n",
    "NOISE = True                              #Test with noise\n",
    "SHOTS = 100000                            #Number of shots to run \n",
    "SHOTS_SINGLE = 1000000                    #Number of shots to run \n",
    "MEASURE_NOISE = 0.0046                    #Measurement noise not relevant\n",
    "SINGLE_GATE_DEPOLARISING = 0.000366       #Single gate noise   \n",
    "TWO_GATE_DEPOLARISING = 0.022\n",
    "FACTOR_LIST = [1, 0.1, 0.01, 0.001, 0.0001]\n",
    "ITERATIONS = 25\n",
    "SIMULATOR = Aer.get_backend('qasm_simulator')\n",
    "TITLE = 'Steane code encoding with fault tolerance'\n",
    "\n",
    "#constants needed for correction and detection with FTc scheme\n",
    "ANC_ZERO = '0000'\n",
    "ANC_ONE = '0001'\n",
    "QUBIT_LIST = [2,4,5] \n",
    "\n",
    "ANCILLA_TYPES = 2\n",
    "ANCILLA_QUBITS = 3\n",
    "ANCILLA_MEASUREMENT_REPEATS = 3\n",
    "\n",
    "DATA_MEASUREMENT_REPEATS = 3\n",
    "DATA_MEAS_QUBITS = 1\n",
    "DATA_MEAS_START = ANCILLA_TYPES * ANCILLA_QUBITS * ANCILLA_MEASUREMENT_REPEATS\n",
    "DATA_START = DATA_MEAS_START + (DATA_MEAS_QUBITS * DATA_MEASUREMENT_REPEATS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We 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": [],
   "source": [
    "parity_check_matrix = ['0001111',\n",
    "                       '0110011',\n",
    "                       '1010101'\n",
    "                      ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "codewords = ['0000000',\n",
    "             '1010101',\n",
    "             '0110011',\n",
    "             '1100110',\n",
    "             '0001111',\n",
    "             '1011010',\n",
    "             '0111100',\n",
    "             '1101001'\n",
    "            ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def single_qubit():\n",
    "    cd = QuantumRegister(1,'data')\n",
    "    sd = ClassicalRegister(1,'measure_data') \n",
    "    qc = QuantumCircuit(cd, sd)\n",
    "    qc.measure(cd, sd)\n",
    "    if NOISE:\n",
    "        result = execute(qc, SIMULATOR, noise_model = noise_model, shots = SHOTS_SINGLE).result()\n",
    "    else:\n",
    "        result = execute(qc, SIMULATOR, shots = SHOTS_SINGLE).result()\n",
    "    counts = result.get_counts(qc)\n",
    "    return(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function module for non fault tolerant decoding circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encoding():\n",
    "    # no fault tolerance\n",
    "    qubit = SteaneCodeLogicalQubit(1, parity_check_matrix, codewords, ancilla = False)\n",
    "    qubit.set_up_logical_zero(0)\n",
    "    qubit.logical_measure_data(0)\n",
    "    if NOISE:\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",
    "    #print(counts)\n",
    "    return(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function module for non fault tolerant decoding circuit, scheme b from Goto's paper.  See worksheet \n",
    "\"Steane_code_encoding_FTb\" for circuit diagram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encoding_FTb():\n",
    "    qubit = SteaneCodeLogicalQubit(2, parity_check_matrix, codewords, \n",
    "                                   ancilla = False, fault_tolerant_b = True, \n",
    "                                   data_rounds = 3\n",
    "                                  )\n",
    "    qubit.set_up_logical_zero(0)\n",
    "    for i in range(3):\n",
    "        qubit.barrier()\n",
    "        qubit.set_up_logical_zero(1)\n",
    "        qubit.barrier()\n",
    "        qubit.logical_gate_CX(0, 1)\n",
    "        qubit.barrier()\n",
    "        qubit.logical_measure_data_FT(logical_qubit = 1, measure_round = i + 1)\n",
    "        qubit.barrier() \n",
    "    qubit.logical_measure_data(0)\n",
    "    if NOISE:\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",
    "    return(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function module for non fault tolerant decoding circuit, scheme c from Goto's paper.  See worksheet \n",
    "\"Steane_code_encoding_FTc\" for circuit diagram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encoding_FTc():\n",
    "    qubit = SteaneCodeLogicalQubit(1, parity_check_matrix, codewords, ancilla = False, \n",
    "                                   fault_tolerant_c = True, data_rounds = 3,                )\n",
    "    qubit.set_up_logical_zero(0)\n",
    "    qubit.barrier()\n",
    "    qubit.barrier()\n",
    "    for i in range(3):\n",
    "        qubit.encode_fault_tolerant_method_C(QUBIT_LIST)\n",
    "        qubit.barrier()\n",
    "        qubit.logical_measure_data_FT(0, i + 1)\n",
    "        qubit.barrier()\n",
    "    qubit.logical_measure_data(0)\n",
    "    qubit.barrier() \n",
    "    if NOISE:\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",
    "    #print(counts)\n",
    "    return(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function module for non fault tolerant decoding circuit, based on own design.  See worksheet \n",
    "\"Steane_code_encoding_FTd\" for circuit diagram."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encoding_FTd():\n",
    "    qubit = SteaneCodeLogicalQubit(2, parity_check_matrix, codewords, \n",
    "                                   ancilla = False, fault_tolerant_b = True, \n",
    "                                   data_rounds = 3\n",
    "                                  )\n",
    "    qubit.set_up_logical_zero(0)\n",
    "    for i in range(3):\n",
    "        qubit.barrier()\n",
    "        qubit.logical_data_reset(1)\n",
    "        qubit.barrier()\n",
    "        qubit.logical_gate_CX(0, 1)\n",
    "        qubit.barrier()\n",
    "        qubit.logical_measure_data_FT(logical_qubit = 1, measure_round = i + 1)\n",
    "        qubit.barrier() \n",
    "    qubit.logical_measure_data(0)\n",
    "    if NOISE:\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",
    "    #print(counts)\n",
    "    return(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function module for non fault tolerant decoding circuit, scheme c from Goto's paper, with FT ancilla.  See worksheet \n",
    "\"Steane_code_encoding_FTc\" for circuit diagram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encoding_and_detection_FTc():\n",
    "    qubit = SteaneCodeLogicalQubit(1, parity_check_matrix, codewords, \n",
    "                           fault_tolerant_ancilla = True, fault_tolerant_c = True, \n",
    "                           ancilla_rounds = 3, data_rounds = 3\n",
    "                          )\n",
    "    qubit.set_up_logical_zero(0)\n",
    "    for i in range(ANCILLA_MEASUREMENT_REPEATS):\n",
    "        qubit.encode_fault_tolerant_method_C(QUBIT_LIST)\n",
    "        qubit.barrier()\n",
    "        qubit.logical_measure_data_FT(0, i + 1)\n",
    "        qubit.barrier()\n",
    "    for i in range(ANCILLA_MEASUREMENT_REPEATS):\n",
    "        qubit.set_up_ancilla(0)\n",
    "        qubit.logical_measure_ancilla(0, i)\n",
    "    qubit.logical_measure_data(0)\n",
    "    if NOISE:\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",
    "    return(counts)\n",
    "    #print ('The different states can be counted.  The simulated result are', counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function module for non FT circuit with ancilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encoding_with_ancilla():\n",
    "    # no fault tolerance\n",
    "    qubit = SteaneCodeLogicalQubit(1, parity_check_matrix, codewords)\n",
    "    qubit.set_up_logical_zero(0)\n",
    "    qubit.set_up_ancilla(0)\n",
    "    qubit.logical_measure_data(0)\n",
    "    qubit.logical_measure_ancilla(0)\n",
    "    if NOISE:\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",
    "    #print(counts)\n",
    "    return(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculation and processing of results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Current Time = 17:09:14\n",
      "Processing factor 1\n",
      "Processing single qubit\n",
      "The mean is 0.004601, the standard error is 0.000017\n",
      "The standard devation is 0.000083\n",
      "\n",
      "process non FT circuit\n",
      "The mean is 0.186513, the standard error is 0.000194\n",
      "The standard devations 0.000969\n",
      "\n",
      "Processing FTb\n",
      "The mean is 0.106585, the standard error is 0.000340\n",
      "The standard devation is 0.001700\n",
      "\n",
      "Processing FTc\n",
      "The mean is 0.128457, the standard error is 0.000244\n",
      "The standard devation is 0.001221\n",
      "\n",
      "Processing FTd\n",
      "The mean is 0.104526, the standard error is 0.000260\n",
      "The standard devation is 0.001299\n",
      "\n",
      "process FTc with FT ancilla\n",
      "The mean is 0.130407, the standard error is 0.003320\n",
      "The standard devations 0.016602\n",
      "\n",
      "process non FT circuit with ancilla\n",
      "The mean is 0.324198, the standard error is 0.000305\n",
      "The standard devations 0.001523\n",
      "\n",
      "\n",
      "Current Time = 18:11:28\n",
      "Processing factor 0.1\n",
      "Processing single qubit\n",
      "The mean is 0.000459, the standard error is 0.000004\n",
      "The standard devation is 0.000022\n",
      "\n",
      "process non FT circuit\n",
      "The mean is 0.020702, the standard error is 0.000095\n",
      "The standard devations 0.000476\n",
      "\n",
      "Processing FTb\n",
      "The mean is 0.010856, the standard error is 0.000055\n",
      "The standard devation is 0.000273\n",
      "\n",
      "Processing FTc\n",
      "The mean is 0.013201, the standard error is 0.000070\n",
      "The standard devation is 0.000352\n",
      "\n",
      "Processing FTd\n",
      "The mean is 0.010924, the standard error is 0.000080\n",
      "The standard devation is 0.000402\n",
      "\n",
      "process FTc with FT ancilla\n",
      "The mean is 0.012287, the standard error is 0.000096\n",
      "The standard devations 0.000481\n",
      "\n",
      "process non FT circuit with ancilla\n",
      "The mean is 0.037189, the standard error is 0.000115\n",
      "The standard devations 0.000576\n",
      "\n",
      "\n",
      "Current Time = 19:10:45\n",
      "Processing factor 0.01\n",
      "Processing single qubit\n",
      "The mean is 0.000046, the standard error is 0.000001\n",
      "The standard devation is 0.000007\n",
      "\n",
      "process non FT circuit\n",
      "The mean is 0.002085, the standard error is 0.000024\n",
      "The standard devations 0.000119\n",
      "\n",
      "Processing FTb\n",
      "The mean is 0.001100, the standard error is 0.000023\n",
      "The standard devation is 0.000116\n",
      "\n",
      "Processing FTc\n",
      "The mean is 0.001280, the standard error is 0.000025\n",
      "The standard devation is 0.000125\n",
      "\n",
      "Processing FTd\n",
      "The mean is 0.001076, the standard error is 0.000023\n",
      "The standard devation is 0.000113\n",
      "\n",
      "process FTc with FT ancilla\n",
      "The mean is 0.001231, the standard error is 0.000025\n",
      "The standard devations 0.000127\n",
      "\n",
      "process non FT circuit with ancilla\n",
      "The mean is 0.003860, the standard error is 0.000044\n",
      "The standard devations 0.000218\n",
      "\n",
      "\n",
      "Current Time = 20:09:02\n",
      "Processing factor 0.001\n",
      "Processing single qubit\n",
      "The mean is 0.000004, the standard error is 0.000001\n",
      "The standard devation is 0.000003\n",
      "\n",
      "process non FT circuit\n",
      "The mean is 0.000203, the standard error is 0.000009\n",
      "The standard devations 0.000044\n",
      "\n",
      "Processing FTb\n",
      "The mean is 0.000101, the standard error is 0.000006\n",
      "The standard devation is 0.000030\n",
      "\n",
      "Processing FTc\n",
      "The mean is 0.000134, the standard error is 0.000008\n",
      "The standard devation is 0.000039\n",
      "\n",
      "Processing FTd\n",
      "The mean is 0.000109, the standard error is 0.000007\n",
      "The standard devation is 0.000033\n",
      "\n",
      "process FTc with FT ancilla\n",
      "The mean is 0.000107, the standard error is 0.000007\n",
      "The standard devations 0.000035\n",
      "\n",
      "process non FT circuit with ancilla\n",
      "The mean is 0.000364, the standard error is 0.000012\n",
      "The standard devations 0.000058\n",
      "\n",
      "\n",
      "Current Time = 21:07:14\n",
      "Processing factor 0.0001\n",
      "Processing single qubit\n",
      "The mean is 0.000000, the standard error is 0.000000\n",
      "The standard devation is 0.000000\n",
      "\n",
      "process non FT circuit\n",
      "The mean is 0.000020, the standard error is 0.000003\n",
      "The standard devations 0.000013\n",
      "\n",
      "Processing FTb\n",
      "The mean is 0.000009, the standard error is 0.000002\n",
      "The standard devation is 0.000010\n",
      "\n",
      "Processing FTc\n",
      "The mean is 0.000018, the standard error is 0.000003\n",
      "The standard devation is 0.000013\n",
      "\n",
      "Processing FTd\n",
      "The mean is 0.000012, the standard error is 0.000002\n",
      "The standard devation is 0.000010\n",
      "\n",
      "process FTc with FT ancilla\n",
      "The mean is 0.000014, the standard error is 0.000003\n",
      "The standard devations 0.000013\n",
      "\n",
      "process non FT circuit with ancilla\n",
      "The mean is 0.000039, the standard error is 0.000004\n",
      "The standard devations 0.000018\n",
      "\n"
     ]
    }
   ],
   "source": [
    "single = []\n",
    "nonft = []\n",
    "ftb = []\n",
    "ftc = []\n",
    "ftd = []\n",
    "ftca = []\n",
    "nonfta = []\n",
    "error_single = []\n",
    "error_nonft = []\n",
    "error_ftb = []\n",
    "error_ftc = []\n",
    "error_ftd = []\n",
    "error_ftca = []\n",
    "error_nonfta = []\n",
    "\n",
    "for factor in FACTOR_LIST:\n",
    "    print()\n",
    "    print_time()\n",
    "    print(f'Processing factor {factor}')\n",
    "    if NOISE:\n",
    "        noise_model = get_noise(MEASURE_NOISE * factor, SINGLE_GATE_DEPOLARISING * factor, \n",
    "                                TWO_GATE_DEPOLARISING * factor, SINGLE_GATE_ERRORS, TWO_GATE_ERRORS\n",
    "                               )\n",
    "               \n",
    "    print('Processing single qubit')\n",
    "    results_list = []\n",
    "    for iteration in range(ITERATIONS):\n",
    "        counts = single_qubit()\n",
    "        error_rate, rejected, accepted, valid, invalid = process_FT_results(counts, '0')\n",
    "        results_list.append(error_rate)\n",
    "    mean = mean_of_list(results_list)\n",
    "    standard_deviation, standard_error = calculate_standard_error(results_list)\n",
    "    print(f'The mean is {mean:.6f}, the standard error is {standard_error:.6f}')\n",
    "    print(f'The standard devation is {standard_deviation:.6f}')\n",
    "    single.append(mean)\n",
    "    error_single.append(standard_error)\n",
    "    print()\n",
    "    \n",
    "    print('process non FT circuit')\n",
    "    results_list = []\n",
    "    for iteration in range(ITERATIONS):\n",
    "        counts = encoding()\n",
    "        error_rate, rejected, accepted, valid, invalid = process_FT_results(counts, codewords, verbose = False,)\n",
    "        results_list.append(error_rate)\n",
    "    mean = mean_of_list(results_list)\n",
    "    standard_deviation, standard_error = calculate_standard_error(results_list)\n",
    "    print(f'The mean is {mean:.6f}, the standard error is {standard_error:.6f}')\n",
    "    print(f'The standard devations {standard_deviation:.6f}')\n",
    "    nonft.append(mean)\n",
    "    error_nonft.append(standard_error)\n",
    "    print()\n",
    "    \n",
    "    print('Processing FTb')\n",
    "    results_list = []\n",
    "    for iteration in range(ITERATIONS):\n",
    "        counts = encoding_FTb()\n",
    "        error_rate, rejected, accepted, valid, invalid = process_FT_results(counts, codewords, verbose = False,\n",
    "                                                                            data_start = 3, data_meas_qubits = 1,\n",
    "                                                                            data_meas_repeats = 3, \n",
    "                                                                            data_meas_strings = codewords\n",
    "                                                                           )\n",
    "        results_list.append(error_rate)\n",
    "    mean = mean_of_list(results_list)\n",
    "    standard_deviation, standard_error = calculate_standard_error(results_list)\n",
    "    print(f'The mean is {mean:.6f}, the standard error is {standard_error:.6f}')\n",
    "    print(f'The standard devation is {standard_deviation:.6f}')\n",
    "    ftb.append(mean)\n",
    "    error_ftb.append(standard_error)\n",
    "    print()\n",
    "    \n",
    "    print('Processing FTc')\n",
    "    results_list = []\n",
    "    for iteration in range(ITERATIONS):\n",
    "        counts = encoding_FTc()\n",
    "        error_rate, rejected, accepted, valid, invalid = process_FT_results(counts, codewords, verbose = False,\n",
    "                                                                            data_start = 3, data_meas_qubits = 1,\n",
    "                                                                            data_meas_repeats = 3, \n",
    "                                                                            data_meas_strings = ['0']\n",
    "                                                                           )\n",
    "        \n",
    "        results_list.append(error_rate)\n",
    "    mean = mean_of_list(results_list)\n",
    "    standard_deviation, standard_error = calculate_standard_error(results_list)\n",
    "    print(f'The mean is {mean:.6f}, the standard error is {standard_error:.6f}')\n",
    "    print(f'The standard devation is {standard_deviation:.6f}')\n",
    "    ftc.append(mean)\n",
    "    error_ftc.append(standard_error)\n",
    "    print()\n",
    "    \n",
    "    print('Processing FTd')\n",
    "    results_list = []\n",
    "    for iteration in range(ITERATIONS):\n",
    "        counts = encoding_FTd()\n",
    "        error_rate, rejected, accepted, valid, invalid = process_FT_results(counts, codewords, verbose = False,\n",
    "                                                                    data_start = 3, data_meas_qubits = 1,\n",
    "                                                                    data_meas_repeats = 3, \n",
    "                                                                    data_meas_strings = codewords\n",
    "                                                                   )\n",
    "        results_list.append(error_rate)\n",
    "    mean = mean_of_list(results_list)\n",
    "    standard_deviation, standard_error = calculate_standard_error(results_list)\n",
    "    print(f'The mean is {mean:.6f}, the standard error is {standard_error:.6f}')\n",
    "    print(f'The standard devation is {standard_deviation:.6f}')\n",
    "    ftd.append(mean)\n",
    "    error_ftd.append(standard_error)\n",
    "    print()\n",
    "    \n",
    "    print('process FTc with FT ancilla')\n",
    "    results_list = []\n",
    "    for iteration in range(ITERATIONS):\n",
    "        counts = encoding_and_detection_FTc()\n",
    "        error_rate, rejected, accepted, valid, invalid = process_FT_results(counts, codewords, \n",
    "                                                                    anc_zero = ANC_ZERO,\n",
    "                                                                    anc_one = ANC_ONE,\n",
    "                                                                    verbose = False,  \n",
    "                                                                    data_meas_start = DATA_MEAS_START, \n",
    "                                                                    data_start = DATA_START,\n",
    "                                                                    ancilla_qubits = ANCILLA_QUBITS, \n",
    "                                                                    ancilla_meas_repeats = ANCILLA_MEASUREMENT_REPEATS,\n",
    "                                                                    data_meas_qubits = DATA_MEAS_QUBITS, \n",
    "                                                                    data_meas_repeats = DATA_MEASUREMENT_REPEATS\n",
    "                                                                    )\n",
    "        results_list.append(error_rate)\n",
    "    mean = mean_of_list(results_list)\n",
    "    standard_deviation, standard_error = calculate_standard_error(results_list)\n",
    "    print(f'The mean is {mean:.6f}, the standard error is {standard_error:.6f}')\n",
    "    print(f'The standard devations {standard_deviation:.6f}')\n",
    "    ftca.append(mean)\n",
    "    error_ftca.append(standard_error)\n",
    "    print()\n",
    "    \n",
    "    print('process non FT circuit with ancilla')\n",
    "    results_list = []\n",
    "    for iteration in range(ITERATIONS):\n",
    "        counts = encoding_with_ancilla()\n",
    "        error_rate, rejected, accepted, valid, invalid = process_FT_results(counts, codewords, verbose = False,\n",
    "                                                                            data_start = 2, \n",
    "                                                                            ancilla_qubits = 1)\n",
    "        results_list.append(error_rate)\n",
    "    mean = mean_of_list(results_list)\n",
    "    standard_deviation, standard_error = calculate_standard_error(results_list)\n",
    "    print(f'The mean is {mean:.6f}, the standard error is {standard_error:.6f}')\n",
    "    print(f'The standard devations {standard_deviation:.6f}')\n",
    "    nonfta.append(mean)\n",
    "    error_nonfta.append(standard_error)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "color1 = 'black'\n",
    "color2 = '#045257'\n",
    "color3 = '#089099'\n",
    "color4 = '#7CCBA2'\n",
    "color5 = '#F0746F'\n",
    "color6 = '#7C1D6F'\n",
    "color7 = '#DC3977'\n",
    "plt.plot(FACTOR_LIST, single, '.', color = color1, linestyle = '', label = 'Single qubit' )\n",
    "plt.plot(FACTOR_LIST, ftb, '.', color = color2, linestyle = '', label = 'FT encoding B' )\n",
    "plt.plot(FACTOR_LIST, ftc, '.', color = color3, linestyle = '', label = 'FT encoding C' )\n",
    "plt.plot(FACTOR_LIST, ftd, '.', color = color4, linestyle = '', label = 'FT encoding D' )\n",
    "plt.plot(FACTOR_LIST, nonft, '.', color = color5, linestyle = '', label = 'Non FT encoding' )\n",
    "plt.plot(FACTOR_LIST, ftca, '.', color = color6, linestyle = '', label = 'FT encoding C + FT ancilla' )\n",
    "plt.plot(FACTOR_LIST, nonfta, '.', color = color7, linestyle = '', label = 'Non FT encoding + ancilla' )\n",
    "plt.errorbar(FACTOR_LIST, single, yerr = error_single, color = color1 )   \n",
    "plt.errorbar(FACTOR_LIST, ftb, yerr = error_ftb, color = color2 )\n",
    "plt.errorbar(FACTOR_LIST, ftc, yerr = error_ftc, color = color3 )\n",
    "plt.errorbar(FACTOR_LIST, ftd, yerr = error_ftd, color = color4 )\n",
    "plt.errorbar(FACTOR_LIST, nonft, yerr = error_nonft, color = color5 )\n",
    "plt.errorbar(FACTOR_LIST, ftca, yerr = error_ftca, color = color6 )\n",
    "plt.errorbar(FACTOR_LIST, nonfta, yerr = error_nonfta, color = color7 )\n",
    "plt.xlabel('Error scaling factor')\n",
    "plt.ylabel('Error rate')\n",
    "plt.title(TITLE)\n",
    "plt.xscale(\"log\")\n",
    "plt.yscale(\"log\")\n",
    "plt.legend(bbox_to_anchor=(0, 1), ncol = 2, loc = 2, borderaxespad = 0., prop={\"size\":8})\n",
    "fname = TITLE + '.png'\n",
    "plt.savefig(fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}