Steane_code_FT_encoding_post_select.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",
    "    get_parity_check_matrix,\n",
    "    get_codewords\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",
    "\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": [
    "The parity check matrix is specified, 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 codewords are used to find if output strings are valid.  "
   ]
  },
  {
   "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": [
    "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 = 18:57:02\n",
      "Processing factor 1\n",
      "Processing single qubit\n",
      "The mean is 0.00459516, the standard error is 0.00001569\n",
      "The standard devation is 0.00007844\n",
      "\n",
      "process non FT circuit\n",
      "Without post selection\n",
      "  The mean is 0.18699440, the standard error is 0.00022669\n",
      "  The standard devations 0.00113344\n",
      "With post selection\n",
      "  The mean is 0.00049640, the standard error is 0.00000814\n",
      "  The standard devations 0.000041\n",
      "\n",
      "Processing FTb\n",
      "Without post selection\n",
      "  The mean is 0.10617018, the standard error is 0.00033766\n",
      "  The standard devations 0.00168831\n",
      "With post selection\n",
      "  The mean is 0.00002204, the standard error is 0.00000554\n",
      "  The standard devations 0.00002772\n",
      "\n",
      "Processing FTc\n",
      "Without post selection\n",
      "  The mean is 0.12866847, the standard error is 0.00022644\n",
      "  The standard devations 0.00113219\n",
      "With post selection\n",
      "  The mean is 0.00024569, the standard error is 0.00000846\n",
      "  The standard devations 0.00004230\n",
      "\n",
      "Processing FTd\n",
      "Without post selection\n",
      "  The mean is 0.10443823, the standard error is 0.00021204\n",
      "  The standard devations 0.00106018\n",
      "With post selection\n",
      "  The mean is 0.00002388, the standard error is 0.00000513\n",
      "  The standard devations 0.00002564\n",
      "\n",
      "process FTc with FT ancilla\n",
      "Without post selection\n",
      "  The mean is 0.13713224, the standard error is 0.00322825\n",
      "  The standard devations 0.01614124\n",
      "With post selection\n",
      "  The mean is 0.02363559, the standard error is 0.00167329\n",
      "  The standard devations 0.00836647\n",
      "\n",
      "process non FT circuit with ancilla\n",
      "Without post selection\n",
      "  The mean is 0.32367880, the standard error is 0.00024889\n",
      "  The standard devations 0.00124444\n",
      "With post selection\n",
      "  The mean is 0.06216320, the standard error is 0.00011574\n",
      "  The standard devations 0.00057868\n",
      "\n",
      "\n",
      "Current Time = 19:57:51\n",
      "Processing factor 0.1\n",
      "Processing single qubit\n",
      "The mean is 0.00046392, the standard error is 0.00000482\n",
      "The standard devation is 0.00002410\n",
      "\n",
      "process non FT circuit\n",
      "Without post selection\n",
      "  The mean is 0.02064880, the standard error is 0.00009149\n",
      "  The standard devations 0.00045743\n",
      "With post selection\n",
      "  The mean is 0.00000200, the standard error is 0.00000082\n",
      "  The standard devations 0.000004\n",
      "\n",
      "Processing FTb\n",
      "Without post selection\n",
      "  The mean is 0.01099905, the standard error is 0.00006754\n",
      "  The standard devations 0.00033771\n",
      "With post selection\n",
      "  The mean is 0.00000000, the standard error is 0.00000000\n",
      "  The standard devations 0.00000000\n",
      "\n",
      "Processing FTc\n",
      "Without post selection\n",
      "  The mean is 0.01309028, the standard error is 0.00007275\n",
      "  The standard devations 0.00036375\n",
      "With post selection\n",
      "  The mean is 0.00000165, the standard error is 0.00000097\n",
      "  The standard devations 0.00000487\n",
      "\n",
      "Processing FTd\n",
      "Without post selection\n",
      "  The mean is 0.01096030, the standard error is 0.00008146\n",
      "  The standard devations 0.00040730\n",
      "With post selection\n",
      "  The mean is 0.00000000, the standard error is 0.00000000\n",
      "  The standard devations 0.00000000\n",
      "\n",
      "process FTc with FT ancilla\n",
      "Without post selection\n",
      "  The mean is 0.01206946, the standard error is 0.00010996\n",
      "  The standard devations 0.00054980\n",
      "With post selection\n",
      "  The mean is 0.00119402, the standard error is 0.00003341\n",
      "  The standard devations 0.00016706\n",
      "\n",
      "process non FT circuit with ancilla\n",
      "Without post selection\n",
      "  The mean is 0.03711840, the standard error is 0.00014033\n",
      "  The standard devations 0.00070163\n",
      "With post selection\n",
      "  The mean is 0.00661120, the standard error is 0.00004991\n",
      "  The standard devations 0.00024955\n",
      "\n",
      "\n",
      "Current Time = 20:55:21\n",
      "Processing factor 0.01\n",
      "Processing single qubit\n",
      "The mean is 0.00004468, the standard error is 0.00000105\n",
      "The standard devation is 0.00000523\n",
      "\n",
      "process non FT circuit\n",
      "Without post selection\n",
      "  The mean is 0.00205520, the standard error is 0.00002947\n",
      "  The standard devations 0.00014734\n",
      "With post selection\n",
      "  The mean is 0.00000040, the standard error is 0.00000040\n",
      "  The standard devations 0.000002\n",
      "\n",
      "Processing FTb\n",
      "Without post selection\n",
      "  The mean is 0.00108003, the standard error is 0.00001946\n",
      "  The standard devations 0.00009731\n",
      "With post selection\n",
      "  The mean is 0.00000000, the standard error is 0.00000000\n",
      "  The standard devations 0.00000000\n",
      "\n",
      "Processing FTc\n",
      "Without post selection\n",
      "  The mean is 0.00137242, the standard error is 0.00002065\n",
      "  The standard devations 0.00010327\n",
      "With post selection\n",
      "  The mean is 0.00000000, the standard error is 0.00000000\n",
      "  The standard devations 0.00000000\n",
      "\n",
      "Processing FTd\n",
      "Without post selection\n",
      "  The mean is 0.00108262, the standard error is 0.00001911\n",
      "  The standard devations 0.00009556\n",
      "With post selection\n",
      "  The mean is 0.00000000, the standard error is 0.00000000\n",
      "  The standard devations 0.00000000\n",
      "\n",
      "process FTc with FT ancilla\n",
      "Without post selection\n",
      "  The mean is 0.00122111, the standard error is 0.00001839\n",
      "  The standard devations 0.00009197\n",
      "With post selection\n",
      "  The mean is 0.00011503, the standard error is 0.00000727\n",
      "  The standard devations 0.00003633\n",
      "\n",
      "process non FT circuit with ancilla\n",
      "Without post selection\n",
      "  The mean is 0.00373600, the standard error is 0.00003893\n",
      "  The standard devations 0.00019466\n",
      "With post selection\n",
      "  The mean is 0.00066160, the standard error is 0.00002005\n",
      "  The standard devations 0.00010024\n",
      "\n",
      "\n",
      "Current Time = 21:52:49\n",
      "Processing factor 0.001\n",
      "Processing single qubit\n",
      "The mean is 0.00000420, the standard error is 0.00000038\n",
      "The standard devation is 0.00000189\n",
      "\n",
      "process non FT circuit\n",
      "Without post selection\n",
      "  The mean is 0.00020320, the standard error is 0.00000883\n",
      "  The standard devations 0.00004413\n",
      "With post selection\n",
      "  The mean is 0.00000000, the standard error is 0.00000000\n",
      "  The standard devations 0.000000\n",
      "\n",
      "Processing FTb\n",
      "Without post selection\n",
      "  The mean is 0.00011534, the standard error is 0.00000615\n",
      "  The standard devations 0.00003074\n",
      "With post selection\n",
      "  The mean is 0.00000000, the standard error is 0.00000000\n",
      "  The standard devations 0.00000000\n",
      "\n",
      "Processing FTc\n",
      "Without post selection\n",
      "  The mean is 0.00012124, the standard error is 0.00000644\n",
      "  The standard devations 0.00003220\n",
      "With post selection\n",
      "  The mean is 0.00000000, the standard error is 0.00000000\n",
      "  The standard devations 0.00000000\n",
      "\n",
      "Processing FTd\n",
      "Without post selection\n",
      "  The mean is 0.00010527, the standard error is 0.00000542\n",
      "  The standard devations 0.00002712\n",
      "With post selection\n",
      "  The mean is 0.00000000, the standard error is 0.00000000\n",
      "  The standard devations 0.00000000\n",
      "\n",
      "process FTc with FT ancilla\n",
      "Without post selection\n",
      "  The mean is 0.00012352, the standard error is 0.00000705\n",
      "  The standard devations 0.00003526\n",
      "With post selection\n",
      "  The mean is 0.00001247, the standard error is 0.00000212\n",
      "  The standard devations 0.00001058\n",
      "\n",
      "process non FT circuit with ancilla\n",
      "Without post selection\n",
      "  The mean is 0.00039400, the standard error is 0.00001143\n",
      "  The standard devations 0.00005715\n",
      "With post selection\n",
      "  The mean is 0.00006160, the standard error is 0.00000544\n",
      "  The standard devations 0.00002718\n",
      "\n",
      "\n",
      "Current Time = 22:49:57\n",
      "Processing factor 0.0001\n",
      "Processing single qubit\n",
      "The mean is 0.00000048, the standard error is 0.00000013\n",
      "The standard devation is 0.00000065\n",
      "\n",
      "process non FT circuit\n",
      "Without post selection\n",
      "  The mean is 0.00002240, the standard error is 0.00000302\n",
      "  The standard devations 0.00001508\n",
      "With post selection\n",
      "  The mean is 0.00000000, the standard error is 0.00000000\n",
      "  The standard devations 0.000000\n",
      "\n",
      "Processing FTb\n",
      "Without post selection\n",
      "  The mean is 0.00000880, the standard error is 0.00000185\n",
      "  The standard devations 0.00000927\n",
      "With post selection\n",
      "  The mean is 0.00000000, the standard error is 0.00000000\n",
      "  The standard devations 0.00000000\n",
      "\n",
      "Processing FTc\n",
      "Without post selection\n",
      "  The mean is 0.00001120, the standard error is 0.00000203\n",
      "  The standard devations 0.00001013\n",
      "With post selection\n",
      "  The mean is 0.00000000, the standard error is 0.00000000\n",
      "  The standard devations 0.00000000\n",
      "\n",
      "Processing FTd\n",
      "Without post selection\n",
      "  The mean is 0.00001080, the standard error is 0.00000238\n",
      "  The standard devations 0.00001188\n",
      "With post selection\n",
      "  The mean is 0.00000000, the standard error is 0.00000000\n",
      "  The standard devations 0.00000000\n",
      "\n",
      "process FTc with FT ancilla\n",
      "Without post selection\n",
      "  The mean is 0.00000961, the standard error is 0.00000147\n",
      "  The standard devations 0.00000735\n",
      "With post selection\n",
      "  The mean is 0.00000160, the standard error is 0.00000075\n",
      "  The standard devations 0.00000374\n",
      "\n",
      "process non FT circuit with ancilla\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Without post selection\n",
      "  The mean is 0.00004000, the standard error is 0.00000408\n",
      "  The standard devations 0.00002041\n",
      "With post selection\n",
      "  The mean is 0.00000880, the standard error is 0.00000167\n",
      "  The standard devations 0.00000833\n",
      "\n"
     ]
    }
   ],
   "source": [
    "single = []\n",
    "\n",
    "nonft = []\n",
    "ftb = []\n",
    "ftc = []\n",
    "ftd = []\n",
    "ftca = []\n",
    "nonfta = []\n",
    "\n",
    "nonft_ps = []\n",
    "ftb_ps = []\n",
    "ftc_ps = []\n",
    "ftd_ps = []\n",
    "ftca_ps = []\n",
    "nonfta_ps = []\n",
    "\n",
    "error_single = []\n",
    "error_nonft = []\n",
    "error_ftb = []\n",
    "error_ftc = []\n",
    "error_ftd = []\n",
    "error_ftca = []\n",
    "error_nonfta = []\n",
    "\n",
    "error_nonft_ps = []\n",
    "error_ftb_ps = []\n",
    "error_ftc_ps = []\n",
    "error_ftd_ps = []\n",
    "error_ftca_ps = []\n",
    "error_nonfta_ps = []\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:.8f}, the standard error is {standard_error:.8f}')\n",
    "    print(f'The standard devation is {standard_deviation:.8f}')\n",
    "    single.append(mean)\n",
    "    error_single.append(standard_error)\n",
    "    print()\n",
    "    \n",
    "    print('process non FT circuit')\n",
    "    results_list = []\n",
    "    results_list_ps = []\n",
    "    for iteration in range(ITERATIONS):\n",
    "        counts = encoding()\n",
    "        error_rate, rej, acc, val, inval = process_FT_results(counts, codewords, verbose = False)\n",
    "        error_rate_ps, rej_ps, acc_ps, val_ps, inval_ps = process_FT_results(counts, codewords, \n",
    "                                                                                 verbose = False, \n",
    "                                                                                 post_selection = True\n",
    "                                                                                )\n",
    "        results_list.append(error_rate)\n",
    "        results_list_ps.append(error_rate_ps)\n",
    "    mean = mean_of_list(results_list)\n",
    "    mean_ps = mean_of_list(results_list_ps)\n",
    "    standard_deviation, standard_error = calculate_standard_error(results_list)\n",
    "    standard_deviation_ps, standard_error_ps = calculate_standard_error(results_list_ps)\n",
    "    print(f'Without post selection')\n",
    "    print(f'  The mean is {mean:.8f}, the standard error is {standard_error:.8f}')\n",
    "    print(f'  The standard devations {standard_deviation:.8f}')\n",
    "    print(f'With post selection')\n",
    "    print(f'  The mean is {mean_ps:.8f}, the standard error is {standard_error_ps:.8f}')\n",
    "    print(f'  The standard devations {standard_deviation_ps:.6f}')\n",
    "    nonft.append(mean)\n",
    "    error_nonft.append(standard_error_ps)\n",
    "    nonft_ps.append(mean_ps)\n",
    "    error_nonft_ps.append(standard_error_ps)\n",
    "    print()\n",
    "    \n",
    "    print('Processing FTb')\n",
    "    results_list = []\n",
    "    results_list_ps = []\n",
    "    for iteration in range(ITERATIONS):\n",
    "        counts = encoding_FTb()\n",
    "        error_rate, rej, acc, val, inval  = 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",
    "                                                                            post_selection = False\n",
    "                                                                           )\n",
    "        error_rate_ps, rej_ps, acc_ps, val_ps, inval_ps  = 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",
    "                                                                            post_selection = True\n",
    "                                                                           )\n",
    "        results_list.append(error_rate)\n",
    "        results_list_ps.append(error_rate_ps)\n",
    "    mean = mean_of_list(results_list)\n",
    "    mean_ps = mean_of_list(results_list_ps)\n",
    "    standard_deviation, standard_error = calculate_standard_error(results_list)\n",
    "    standard_deviation_ps, standard_error_ps = calculate_standard_error(results_list_ps)\n",
    "    print(f'Without post selection')\n",
    "    print(f'  The mean is {mean:.8f}, the standard error is {standard_error:.8f}')\n",
    "    print(f'  The standard devations {standard_deviation:.8f}')\n",
    "    print(f'With post selection')\n",
    "    print(f'  The mean is {mean_ps:.8f}, the standard error is {standard_error_ps:.8f}')\n",
    "    print(f'  The standard devations {standard_deviation_ps:.8f}')\n",
    "    ftb.append(mean)\n",
    "    error_ftb.append(standard_error)\n",
    "    ftb_ps.append(mean_ps)\n",
    "    error_ftb_ps.append(standard_error_ps)\n",
    "    print()\n",
    "    \n",
    "    print('Processing FTc')\n",
    "    results_list = []\n",
    "    results_list_ps = []\n",
    "    for iteration in range(ITERATIONS):\n",
    "        counts = encoding_FTc()\n",
    "        error_rate, rej, acc, val, inval  = 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",
    "                                                                post_selection = False\n",
    "                                                                )\n",
    "        error_rate_ps, rej_ps, acc_ps, val_ps, inval_ps  = 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",
    "                                                                            post_selection = True \n",
    "                                                                           )\n",
    "        \n",
    "        results_list.append(error_rate)\n",
    "        results_list_ps.append(error_rate_ps)\n",
    "    mean = mean_of_list(results_list)\n",
    "    standard_deviation, standard_error = calculate_standard_error(results_list)\n",
    "    mean_ps = mean_of_list(results_list_ps)\n",
    "    standard_deviation_ps, standard_error_ps = calculate_standard_error(results_list_ps)\n",
    "    print(f'Without post selection')\n",
    "    print(f'  The mean is {mean:.8f}, the standard error is {standard_error:.8f}')\n",
    "    print(f'  The standard devations {standard_deviation:.8f}')\n",
    "    print(f'With post selection')\n",
    "    print(f'  The mean is {mean_ps:.8f}, the standard error is {standard_error_ps:.8f}')\n",
    "    print(f'  The standard devations {standard_deviation_ps:.8f}')\n",
    "    ftc.append(mean)\n",
    "    error_ftc.append(standard_error)\n",
    "    ftc_ps.append(mean_ps)\n",
    "    error_ftc_ps.append(standard_error_ps)\n",
    "    print()\n",
    "    \n",
    "    print('Processing FTd')\n",
    "    results_list = []\n",
    "    results_list_ps = []\n",
    "    for iteration in range(ITERATIONS):\n",
    "        counts = encoding_FTd()\n",
    "        error_rate, rej, acc, val, inval = 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",
    "                                                                post_selection = False   \n",
    "                                                                )\n",
    "        error_rate_ps, rej_ps, acc_ps, val_ps, inval_ps = 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",
    "                                                                post_selection = True            \n",
    "                                                                )\n",
    "        results_list.append(error_rate)\n",
    "        results_list_ps.append(error_rate_ps)\n",
    "    mean = mean_of_list(results_list)\n",
    "    standard_deviation, standard_error = calculate_standard_error(results_list)\n",
    "    mean_ps = mean_of_list(results_list_ps)\n",
    "    standard_deviation_ps, standard_error_ps = calculate_standard_error(results_list_ps)\n",
    "    print(f'Without post selection')\n",
    "    print(f'  The mean is {mean:.8f}, the standard error is {standard_error:.8f}')\n",
    "    print(f'  The standard devations {standard_deviation:.8f}')\n",
    "    print(f'With post selection')\n",
    "    print(f'  The mean is {mean_ps:.8f}, the standard error is {standard_error_ps:.8f}')\n",
    "    print(f'  The standard devations {standard_deviation_ps:.8f}')\n",
    "    ftd.append(mean)\n",
    "    error_ftd.append(standard_error)\n",
    "    ftd_ps.append(mean_ps)\n",
    "    error_ftd_ps.append(standard_error_ps)\n",
    "    print()\n",
    "    \n",
    "    print('process FTc with FT ancilla')\n",
    "    results_list = []\n",
    "    results_list_ps = []\n",
    "    for iteration in range(ITERATIONS):\n",
    "        counts = encoding_and_detection_FTc()\n",
    "        error_rate, rej, acc, val, inval = 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",
    "                                                              post_selection = False\n",
    "                                                             )\n",
    "        error_rate_ps, rej_ps, acc_ps, val_ps, inval_ps = 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",
    "                                                                             post_selection = True\n",
    "                                                                            )  \n",
    "        results_list.append(error_rate)\n",
    "        results_list_ps.append(error_rate_ps)\n",
    "    mean = mean_of_list(results_list)\n",
    "    standard_deviation, standard_error = calculate_standard_error(results_list)\n",
    "    mean_ps = mean_of_list(results_list_ps)\n",
    "    standard_deviation_ps, standard_error_ps = calculate_standard_error(results_list_ps)\n",
    "    print(f'Without post selection')\n",
    "    print(f'  The mean is {mean:.8f}, the standard error is {standard_error:.8f}')\n",
    "    print(f'  The standard devations {standard_deviation:.8f}')\n",
    "    print(f'With post selection')\n",
    "    print(f'  The mean is {mean_ps:.8f}, the standard error is {standard_error_ps:.8f}')\n",
    "    print(f'  The standard devations {standard_deviation_ps:.8f}')\n",
    "    ftca.append(mean)\n",
    "    error_ftca.append(standard_error)\n",
    "    ftca_ps.append(mean_ps)\n",
    "    error_ftca_ps.append(standard_error_ps)\n",
    "    print()\n",
    "    \n",
    "    print('process non FT circuit with ancilla')\n",
    "    results_list = []\n",
    "    results_list_ps = []\n",
    "    for iteration in range(ITERATIONS):\n",
    "        counts = encoding_with_ancilla()\n",
    "        error_rate, rej, acc, val, inval = process_FT_results(counts, codewords, verbose = False,\n",
    "                                                              data_start = 2, \n",
    "                                                              ancilla_qubits = 1,\n",
    "                                                              post_selection = False\n",
    "                                                             )\n",
    "        error_rate_ps, rej_ps, acc_ps, val_ps, inval_ps = process_FT_results(counts, codewords, verbose = False,\n",
    "                                                                             data_start = 2, \n",
    "                                                                             ancilla_qubits = 1,\n",
    "                                                                             post_selection = True\n",
    "                                                                            )\n",
    "        results_list.append(error_rate)\n",
    "        results_list_ps.append(error_rate_ps)\n",
    "    mean = mean_of_list(results_list)\n",
    "    standard_deviation, standard_error = calculate_standard_error(results_list)\n",
    "    mean_ps = mean_of_list(results_list_ps)\n",
    "    standard_deviation_ps, standard_error_ps = calculate_standard_error(results_list_ps)\n",
    "    print(f'Without post selection')\n",
    "    print(f'  The mean is {mean:.8f}, the standard error is {standard_error:.8f}')\n",
    "    print(f'  The standard devations {standard_deviation:.8f}')\n",
    "    print(f'With post selection')\n",
    "    print(f'  The mean is {mean_ps:.8f}, the standard error is {standard_error_ps:.8f}')\n",
    "    print(f'  The standard devations {standard_deviation_ps:.8f}')\n",
    "    nonfta.append(mean)\n",
    "    error_nonfta.append(standard_error)\n",
    "    nonfta_ps.append(mean_ps)\n",
    "    error_nonfta_ps.append(standard_error_ps)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 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.xlabel('Error scaling factor')\n",
    "#plt.ylabel('Error rate')\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title(TITLE)\n",
    "plt.plot(FACTOR_LIST, single, '.', color = color1, linestyle = '', label = 'Single qubit' )\n",
    "plt.plot(FACTOR_LIST, ftb, '.', color = color2, linestyle = '', label = 'FT encode B' )\n",
    "plt.plot(FACTOR_LIST, ftc, '.', color = color3, linestyle = '', label = 'FT encode C' )\n",
    "plt.plot(FACTOR_LIST, ftd, '.', color = color4, linestyle = '', label = 'FT encode D' )\n",
    "plt.plot(FACTOR_LIST, nonft, '.', color = color5, linestyle = '', label = 'Non FT encode' )\n",
    "plt.plot(FACTOR_LIST, ftca, '.', color = color6, linestyle = '', label = 'FT encode C + FT anc' )\n",
    "plt.plot(FACTOR_LIST, nonfta, '.', color = color7, linestyle = '', label = 'Non FT encode + anc' )\n",
    "\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",
    "\n",
    "plt.xlabel('Error scaling factor')\n",
    "plt.ylabel('Error rate')\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",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(FACTOR_LIST, single, '.', color = color1, linestyle = '', label = 'Single qubit' )\n",
    "plt.plot(FACTOR_LIST, ftb_ps, '.', color = color2, linestyle = '', label = 'FT encode B PS' )\n",
    "plt.plot(FACTOR_LIST, ftc_ps, '.', color = color3, linestyle = '', label = 'FT encode C PS' )\n",
    "plt.plot(FACTOR_LIST, ftd_ps, '.', color = color4, linestyle = '', label = 'FT encode D PS' )\n",
    "plt.plot(FACTOR_LIST, nonft_ps, '.', color = color5, linestyle = '', label = 'Non FT encode PS' )\n",
    "plt.plot(FACTOR_LIST, ftca_ps, '.', color = color6, linestyle = '', label = 'FT encode C + FT anc PS' )\n",
    "plt.plot(FACTOR_LIST, nonfta_ps, '.', color = color7, linestyle = '', label = 'Non FT encode + anc PS' )\n",
    "\n",
    "plt.errorbar(FACTOR_LIST, single, yerr = error_single, color = color1 )   \n",
    "plt.errorbar(FACTOR_LIST, ftb_ps, yerr = error_ftb_ps, color = color2 )\n",
    "plt.errorbar(FACTOR_LIST, ftc_ps, yerr = error_ftc_ps, color = color3 )\n",
    "plt.errorbar(FACTOR_LIST, ftd_ps, yerr = error_ftd_ps, color = color4 )\n",
    "plt.errorbar(FACTOR_LIST, nonft_ps, yerr = error_nonft_ps, color = color5 )\n",
    "plt.errorbar(FACTOR_LIST, ftca_ps, yerr = error_ftca_ps, color = color6 )\n",
    "plt.errorbar(FACTOR_LIST, nonfta_ps, yerr = error_nonfta_ps, color = color7 )\n",
    "\n",
    "plt.xlabel('Error scaling factor')\n",
    "plt.ylabel('Error rate')\n",
    "plt.xscale(\"log\")\n",
    "plt.yscale(\"log\")\n",
    "plt.legend()\n",
    "plt.legend(bbox_to_anchor=(0, 1), ncol = 2, loc = 2, borderaxespad = 0., prop={\"size\":8})\n",
    "\n",
    "fname = TITLE + '.png'\n",
    "plt.savefig(fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": [
    "title = TITLE + ' no PS '\n",
    "plt.title(title)\n",
    "plt.plot(FACTOR_LIST, single, '.', color = color1, linestyle = '', label = 'Single qubit' )\n",
    "plt.plot(FACTOR_LIST, ftb, '.', color = color2, linestyle = '', label = 'FT encode B' )\n",
    "plt.plot(FACTOR_LIST, ftc, '.', color = color3, linestyle = '', label = 'FT encode C' )\n",
    "plt.plot(FACTOR_LIST, ftd, '.', color = color4, linestyle = '', label = 'FT encode D' )\n",
    "plt.plot(FACTOR_LIST, nonft, '.', color = color5, linestyle = '', label = 'Non FT encode' )\n",
    "plt.plot(FACTOR_LIST, ftca, '.', color = color6, linestyle = '', label = 'FT encode C + FT anc' )\n",
    "plt.plot(FACTOR_LIST, nonfta, '.', color = color7, linestyle = '', label = 'Non FT encode + anc' )\n",
    "\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",
    "\n",
    "plt.xlabel('Error scaling factor')\n",
    "plt.ylabel('Error rate')\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",
    "\n",
    "fname = title + '.png'\n",
    "plt.savefig(fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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": [
    "title = TITLE + ' with PS '\n",
    "plt.title(title)\n",
    "plt.plot(FACTOR_LIST, single, '.', color = color1, linestyle = '', label = 'Single qubit' )\n",
    "plt.plot(FACTOR_LIST, ftb_ps, '.', color = color2, linestyle = '', label = 'FT encode B PS' )\n",
    "plt.plot(FACTOR_LIST, ftc_ps, '.', color = color3, linestyle = '', label = 'FT encode C PS' )\n",
    "plt.plot(FACTOR_LIST, ftd_ps, '.', color = color4, linestyle = '', label = 'FT encode D PS' )\n",
    "plt.plot(FACTOR_LIST, nonft_ps, '.', color = color5, linestyle = '', label = 'Non FT encode PS' )\n",
    "plt.plot(FACTOR_LIST, ftca_ps, '.', color = color6, linestyle = '', label = 'FT encode C + FT anc PS' )\n",
    "plt.plot(FACTOR_LIST, nonfta_ps, '.', color = color7, linestyle = '', label = 'Non FT encode + anc PS' )\n",
    "\n",
    "plt.errorbar(FACTOR_LIST, single, yerr = error_single, color = color1 )   \n",
    "plt.errorbar(FACTOR_LIST, ftb_ps, yerr = error_ftb_ps, color = color2 )\n",
    "plt.errorbar(FACTOR_LIST, ftc_ps, yerr = error_ftc_ps, color = color3 )\n",
    "plt.errorbar(FACTOR_LIST, ftd_ps, yerr = error_ftd_ps, color = color4 )\n",
    "plt.errorbar(FACTOR_LIST, nonft_ps, yerr = error_nonft_ps, color = color5 )\n",
    "plt.errorbar(FACTOR_LIST, ftca_ps, yerr = error_ftca_ps, color = color6 )\n",
    "plt.errorbar(FACTOR_LIST, nonfta_ps, yerr = error_nonfta_ps, color = color7 )\n",
    "\n",
    "plt.xlabel('Error scaling factor')\n",
    "plt.ylabel('Error rate')\n",
    "plt.xscale(\"log\")\n",
    "plt.yscale(\"log\")\n",
    "plt.legend()\n",
    "plt.legend(bbox_to_anchor=(0, 1), ncol = 2, loc = 2, borderaxespad = 0., prop={\"size\":8})\n",
    "\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
}