steane-code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "70704c8a",
   "metadata": {},
   "source": [
    "# Simulation of the 7 Qubit Steane QEC Code\n",
    "\n",
    "ECE 621 Quantum Error Correction Final Project\n",
    "\n",
    "Author: Grant Eberle"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09b81c70",
   "metadata": {},
   "source": [
    "Imports and Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "af556528",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, AncillaRegister, Aer, transpile, execute\n",
    "from qiskit.quantum_info import state_fidelity\n",
    "from qiskit.visualization import plot_histogram, plot_state_qsphere\n",
    "from qiskit.providers.aer.noise import depolarizing_error, phase_damping_error\n",
    "from qiskit.providers.aer import AerSimulator\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# Set simulator backend \n",
    "sim = Aer.get_backend('statevector_simulator')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdd18959",
   "metadata": {},
   "source": [
    "## ------- Code Used for Simulations -------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "132bf689",
   "metadata": {},
   "source": [
    "Function for Creating Logical |0> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9ba13ef9",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Encodes the logical |0> state \n",
    "    circuit: circuit output\n",
    "    logRegister: QuantumRegister of logical qubits in the circuit\n",
    "\"\"\"\n",
    "def prepLogicalZero(circuit, logRegister):\n",
    "    circuit.h(logRegister[0])\n",
    "    circuit.h(logRegister[1])\n",
    "    circuit.h(logRegister[3])\n",
    "    circuit.cx(logRegister[0], logRegister[2])\n",
    "    circuit.cx(logRegister[3], logRegister[5])\n",
    "    circuit.cx(logRegister[1], logRegister[6])\n",
    "    circuit.cx(logRegister[0], logRegister[4])\n",
    "    circuit.cx(logRegister[3], logRegister[6])\n",
    "    circuit.cx(logRegister[1], logRegister[5])\n",
    "    circuit.cx(logRegister[0], logRegister[6])\n",
    "    circuit.cx(logRegister[1], logRegister[2])\n",
    "    circuit.cx(logRegister[3], logRegister[4])\n",
    "    return   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f0c6cca",
   "metadata": {},
   "source": [
    "Functions for Stabilizer Encoding "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e59d9fb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Stabilizer Mappings\n",
    "# (Same for X and Z checks because CSS code)\n",
    "S0 = np.array([3, 4, 5, 6])\n",
    "S1 = np.array([1, 2, 5, 6])\n",
    "S2 = np.array([0, 2, 4, 6])\n",
    "\n",
    "\"\"\"\n",
    "Encodes a specified stabilizer in a given circuit\n",
    "    circuit: circuit output\n",
    "    logRegister: QuantumRegister of logical qubits in the circuit\n",
    "    logQubits: qubit indexes of for stabilizer \n",
    "    synRegister: QuantumRegister of syndrome qubits in the circuit\n",
    "    synQubit: index that identifies the syndrome qubit to encode \n",
    "    flag: True -> encode Z stabilizer, False -> encode X stabilizer \n",
    "\"\"\"\n",
    "def encodeStabs(circuit, logRegister, logQubits, synRegister, synQubit, flag):\n",
    "        for i in logQubits:\n",
    "            if flag:\n",
    "                circuit.cz(logRegister[i], synRegister[synQubit])\n",
    "            else:\n",
    "                circuit.cx(synRegister[synQubit], logRegister[i])\n",
    "        return\n",
    "       \n",
    "def encodeXStabs(circuit, logRegister, logQubits, synRegister, synQubit):\n",
    "    encodeStabs(circuit, logRegister, logQubits, synRegister, synQubit, False)\n",
    "    return\n",
    "        \n",
    "def encodeZStabs(circuit, logRegister, logQubits, synRegister, synQubit):\n",
    "    encodeStabs(circuit, logRegister, logQubits, synRegister, synQubit, True)\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a97374d",
   "metadata": {},
   "source": [
    "Functions for Syndrome Extraction and Decoding "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "250aea7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Decodes a syndrome measurement for correction \n",
    "    circuit: circuit output\n",
    "    logRegister: QuantumRegister of logical qubits in the circuit\n",
    "    synMeasurment: Measured value of the synRegister\n",
    "    swap: True -> decode Z stabilizer, False -> decode X stabilizer  \n",
    "        (Note: assumes synRegister is prepared in the proper state for decoding/correction)\n",
    "\"\"\"\n",
    "def decodeSyns(circuit, logRegister, synMeasurement, flag):\n",
    "    if flag: # Z Syndrome -> X correction\n",
    "        for i in range(1, logRegister.size + 1):\n",
    "            circuit.x(logRegister[i - 1]).c_if(synMeasurement, i)\n",
    "    else: # X Syndrome -> Z correction\n",
    "        for i in range(1, logRegister.size + 1):\n",
    "            circuit.z(logRegister[i - 1]).c_if(synMeasurement, i)\n",
    "    return\n",
    "    \n",
    "def decodeXSyndromes(circuit, logRegister, synMeasurement):\n",
    "    decodeSyns(circuit, logRegister, synMeasurement, False)\n",
    "    return\n",
    "    \n",
    "def decodeZSyndromes(circuit, logRegister, synMeasurement):\n",
    "    decodeSyns(circuit, logRegister, synMeasurement, True)\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89fd688b",
   "metadata": {},
   "source": [
    "Function for Single Gate Errors "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d7320fda",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Adds \"level\" number of gates to random qubits on the register with a probabilty based on prob\n",
    "    gate: the gate to be applied as a flip error\n",
    "    register: the register where the error gate will be applied\n",
    "    level: level of error that indicates the number of gates applied\n",
    "    prob: the physical error probability of each gate application\n",
    "\"\"\"\n",
    "def flipError(gate, register, level, prob):\n",
    "    if level == 0: \n",
    "        return\n",
    "    for i in range(level):\n",
    "        randProb = np.random.uniform(0, 1)\n",
    "        qubit = np.random.randint(0, register.size)\n",
    "        if randProb <= prob:\n",
    "            gate(register[qubit])\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e37a34d",
   "metadata": {},
   "source": [
    "Function For Conducting a Single Round of Error Correction "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a23072c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Preforms one round of error correction on a given circuit\n",
    "    circuit: the full QuantumCircuit\n",
    "    logRegister: QuantumRegister of logRegisterical qubits in the circuit\n",
    "    xSynRegister: QuantumRegister of x syndrome qubits in the circuit\n",
    "    zSynRegister: QuantumRegister of z syndrome qubits in the circuit\n",
    "    xMeasurments: ClassicalRegiser of x syndrome measurements in the circuit\n",
    "    zMeasurments: ClassicalRegiser of z syndrome measurements in the circuit\n",
    "    ---\n",
    "    errorLevel: is an optional error level for including measurement errors (for phenom model)\n",
    "    pError: is an optional error rate for including measurement errors (for phenom model)\n",
    "\"\"\"\n",
    "def errorCorrection(circuit, logRegister, xSynRegister, zSynRegister, xMeasurments, zMeasurments, errorLevel, pError):\n",
    "    \n",
    "    \"\"\" Encoding \"\"\" \n",
    "    # X Stabilizers\n",
    "    encodeXStabs(circuit, logRegister, S0, xSynRegister, 0)\n",
    "    encodeXStabs(circuit, logRegister, S1, xSynRegister, 1)\n",
    "    encodeXStabs(circuit, logRegister, S2, xSynRegister, 2)\n",
    "\n",
    "    # Z Stabilizers\n",
    "    encodeZStabs(circuit, logRegister, S0, zSynRegister, 0)\n",
    "    encodeZStabs(circuit, logRegister, S1, zSynRegister, 1)\n",
    "    encodeZStabs(circuit, logRegister, S2, zSynRegister, 2)\n",
    "    \n",
    "    \"\"\" Add Measurement Errors \"\"\"\n",
    "    flipError(circuit.z, xSynRegister, errorLevel, pError)\n",
    "    flipError(circuit.z, zSynRegister, errorLevel, pError)\n",
    "\n",
    "    \"\"\" Syndrome Extraction \"\"\"\n",
    "    # Measure in X basis\n",
    "    circuit.h(xSynRegister) \n",
    "    circuit.h(zSynRegister)\n",
    "    circuit.measure(xSynRegister, xMeasurments)\n",
    "    circuit.measure(zSynRegister, zMeasurments)\n",
    "    \n",
    "    \"\"\" Syndrome Decoding and Correction \"\"\"\n",
    "    # Decode and Correct X\n",
    "    decodeXSyndromes(circuit, logRegister, xMeasurments)\n",
    "\n",
    "    # Decode and Correct Z\n",
    "    decodeZSyndromes(circuit, logRegister, zMeasurments)\n",
    "    \n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9680dc36",
   "metadata": {},
   "source": [
    "Function For Verifying the Logical State "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8ef65985",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Checks a given statevector against a correct logical state\n",
    "    statevector: given statevector of a measured state\n",
    "    correctLogState: Array of string values for each correct superposition state\n",
    "    printText: Shows visual of result if true\n",
    "    returns: True if equal, false if not\n",
    "\"\"\"\n",
    "def verifyLogicalState(statevector, correctLogState, printText):\n",
    "    \n",
    "    # Collect Measured States\n",
    "    indices = []       \n",
    "    for i in range(statevector.dim):\n",
    "        if statevector[i] != 0:\n",
    "            indices.append( ((str(bin(i)[2:]).zfill(3+7)), statevector[i]) )\n",
    "\n",
    "    # Check for size difference\n",
    "    if not (len(indices) == len(correctLogState)):\n",
    "        return False\n",
    "    \n",
    "    # Print Results\n",
    "    if printText:\n",
    "        print('Correct: | Measured:')\n",
    "    j = 0\n",
    "    for i in indices:\n",
    "        correct = correctLogState[j]\n",
    "        measured = str(i[0][3:10][::-1])\n",
    "        if printText:\n",
    "            print(correct, ' | ', measured, ' === ', correct == measured)\n",
    "        if not correct == measured:\n",
    "            return False\n",
    "            \n",
    "        j = j + 1\n",
    "        \n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cde3270",
   "metadata": {},
   "source": [
    "Ideal Circuit Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5a35e85a",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Runs a basline simulation for testing logical |0> state prep\n",
    "    sim: the simulator used for the simulation\n",
    "    returns: statvector of the system after simulation (single shot statvector sim)\n",
    "\"\"\"\n",
    "def zeroLogCircuitSim(sim):\n",
    "    ## Circuit Prep\n",
    "    # Logical Qubit Register\n",
    "    log = QuantumRegister(7, name = \"logical\")\n",
    "\n",
    "    # Circuit\n",
    "    circuit = QuantumCircuit(log) \n",
    "    \n",
    "    # X Syndromes\n",
    "    xSyn = AncillaRegister(3, name = \"xSyn\")\n",
    "\n",
    "    # Z Syndromes\n",
    "    zSyn = AncillaRegister(3, name = \"zSyn\")\n",
    "\n",
    "    # X Syndrome Measurements\n",
    "    xMeas = ClassicalRegister(3, name = \"xMeas\")\n",
    "\n",
    "    # Z Syndrome Measurements\n",
    "    zMeas = ClassicalRegister(3, name = \"zMeas\")\n",
    "\n",
    "    # Full Circuit\n",
    "    circuit = QuantumCircuit(log, xSyn, zSyn, xMeas, zMeas)\n",
    "\n",
    "    # Prepare Logical |0> state\n",
    "    prepLogicalZero(circuit, log)\n",
    "    \n",
    "    return execute(circuit, sim, shots = 1).result().get_statevector()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "10debd69",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Runs a simulation with multiple error options\n",
    "    errorLevel: max number of single qubit gate errors introduced\n",
    "    pError: error rate of single qubit error gates\n",
    "    sim: the simulator used for the simulation\n",
    "    measError: True -> adds errors in sydrome extraction measurements, False does not\n",
    "        (for code capacity vs phenom level sims)\n",
    "    returns: statvector of the system after simulation (single shot statvector sim)\n",
    "\"\"\"\n",
    "def errorCircuitSim(errorLevel, pError, sim, measError):\n",
    "    ## Circuit Prep\n",
    "    # Logical Qubit Register\n",
    "    log = QuantumRegister(7, name = \"logical\")\n",
    "\n",
    "    # X Syndromes\n",
    "    xSyn = AncillaRegister(3, name = \"xSyn\")\n",
    "\n",
    "    # Z Syndromes\n",
    "    zSyn = AncillaRegister(3, name = \"zSyn\")\n",
    "\n",
    "    # X Syndrome Measurements\n",
    "    xMeas = ClassicalRegister(3, name = \"xMeas\")\n",
    "\n",
    "    # Z Syndrome Measurements\n",
    "    zMeas = ClassicalRegister(3, name = \"zMeas\")\n",
    "\n",
    "    # Full Circuit\n",
    "    circuit = QuantumCircuit(log, xSyn, zSyn, xMeas, zMeas)\n",
    "\n",
    "    ## State Prep\n",
    "    # Set Syndrome Qubits to |+>\n",
    "    for i in range(xSyn.size):   \n",
    "        circuit.h(xSyn[i])\n",
    "        circuit.h(zSyn[i])   \n",
    "\n",
    "    # Prepare Logical |0> state\n",
    "    prepLogicalZero(circuit, log)\n",
    "    \n",
    "    \"\"\" APPLY ERRORS \"\"\"  \n",
    "    # Bit Flip Error\n",
    "    flipError(circuit.x, log, errorLevel, pError)\n",
    "    # Phase Flip Error\n",
    "    flipError(circuit.z, log, errorLevel, pError)\n",
    "    \n",
    "    # Error Correction\n",
    "    if measError:\n",
    "        errorCorrection(circuit, log, xSyn, zSyn, xMeas, zMeas, errorLevel, pError)\n",
    "    else:\n",
    "        errorCorrection(circuit, log, xSyn, zSyn, xMeas, zMeas, 0, 0)\n",
    "        \n",
    "    return execute(circuit, sim, shots = 1).result().get_statevector()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "50af66f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Runs a simulation with multiple error options\n",
    "    errorLevel: max number of single qubit gate errors introduced\n",
    "    pError: error rate of single qubit error gates\n",
    "    measError: True -> adds errors in sydrome extraction measurements, False does not\n",
    "     (for code capacity vs phenom level sims)\n",
    "    sim: the simulator used for the simulation\n",
    "    samples: number of sample statvectors used in logical error rate calculation \n",
    "    correctLogState: the state used to determine if there was a logical error \n",
    "    returns: returns logical error rate calculated from samples run (single shot statvector sims)\n",
    "\"\"\"\n",
    "def calculateLogicalError(errorLevel, pError, measError, sim, samples, correctLogState):\n",
    "    logicalErrors = 0;\n",
    "    for i in range(samples):\n",
    "        measuredState = errorCircuitSim(errorLevel, pError, sim, measError)\n",
    "        if not verifyLogicalState(measuredState, correctLogZero, False):\n",
    "            logicalErrors = logicalErrors + 1\n",
    "    return logicalErrors / samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "029de4bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Runs a simulation with multiple error options and returns the logical error rates\n",
    "    errorLevel: max number of single qubit gate errors introduced\n",
    "    pError: error rate of single qubit error gates\n",
    "    measError: True -> adds errors in sydrome extraction measurements, False does not\n",
    "     (for code capacity vs phenom level sims)\n",
    "    sim: the simulator used for the simulation\n",
    "    samples: number of sample statvectors used in logical error rate calculation \n",
    "    correctLogState: the state used to determine if there was a logical error \n",
    "    probs: range of physical error rates for simulations\n",
    "    returns: a plot of the physical/logical error rate threshold \n",
    "\"\"\"\n",
    "def runThresholdCalculation(errorLevel, measError, sim, samples, correctLogState, probs):\n",
    "    logErrorRates = []\n",
    "    print(f'Running Level {errorLevel} Simulations ...')\n",
    "    for p in probs:\n",
    "        if measError:\n",
    "            logErrorRate = calculateLogicalError(errorLevel, p, p, sim, samples, correctLogZero)\n",
    "        else:\n",
    "            logErrorRate = calculateLogicalError(errorLevel, p, 0, sim, samples, correctLogZero)\n",
    "        logErrorRates.append(logErrorRate)\n",
    "    print(f'Level {errorLevel} Simulations Complete') \n",
    "    return logErrorRates"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0e88332",
   "metadata": {},
   "source": [
    "## ------- Testing and Simulations -------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8d7f015",
   "metadata": {},
   "source": [
    "Verification of Proper |0> Logical State Prep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f832c24f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correct: | Measured:\n",
      "0000000  |  0000000  ===  True\n",
      "0111100  |  0111100  ===  True\n",
      "1011010  |  1011010  ===  True\n",
      "1100110  |  1100110  ===  True\n",
      "1101001  |  1101001  ===  True\n",
      "1010101  |  1010101  ===  True\n",
      "0110011  |  0110011  ===  True\n",
      "0001111  |  0001111  ===  True\n",
      "Measured State == Logical |0> State? : True\n"
     ]
    }
   ],
   "source": [
    "# Correct Logical |0> State \n",
    "correctAmp = np.sqrt(1/8)\n",
    "correctLogZero = ['0000000',\n",
    "                  '0111100',\n",
    "                  '1011010',\n",
    "                  '1100110',\n",
    "                  '1101001',\n",
    "                  '1010101',\n",
    "                  '0110011',\n",
    "                  '0001111']\n",
    "\n",
    "# Create and Run Simulator for Prepare Zero Logical State \n",
    "measuredState = zeroLogCircuitSim(sim)\n",
    "\n",
    "# Verify Correct Prep\n",
    "print('Measured State == Logical |0> State? :', verifyLogicalState(measuredState, correctLogZero, True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "247bef35",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set parameter for number of sample statvectors used in logical error rate calculation \n",
    "samples = 1000\n",
    "\n",
    "# Values of Physical Error Rates \n",
    "probs = np.linspace(0,0.5,20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bc55407",
   "metadata": {},
   "source": [
    "## Code Capacity Model Simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d7f97d44",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Level 1 Simulations ...\n",
      "Level 1 Simulations Complete\n"
     ]
    }
   ],
   "source": [
    "\"\"\" Level 1 Pauli X and Z Error Tests \"\"\"\n",
    "ccLevel1 = runThresholdCalculation(1, False, sim, samples, correctLogZero, probs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "eb3ee41c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Level 2 Simulations ...\n",
      "Level 2 Simulations Complete\n"
     ]
    }
   ],
   "source": [
    "\"\"\" Level 2 Pauli X and Z Error Tests \"\"\"\n",
    "ccLevel2 = runThresholdCalculation(2, False, sim, samples, correctLogZero, probs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "2c2274a5",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Level 3 Simulations ...\n",
      "Level 3 Simulations Complete\n"
     ]
    }
   ],
   "source": [
    "\"\"\" Level 3 Pauli X and Z Error Tests \"\"\"\n",
    "ccLevel3 = runThresholdCalculation(3, False, sim, samples, correctLogZero, probs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d48bdae6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Level 4 Simulations ...\n",
      "Level 4 Simulations Complete\n"
     ]
    }
   ],
   "source": [
    "\"\"\" Level 4 Pauli X and Z Error Tests \"\"\"\n",
    "ccLevel4 = runThresholdCalculation(4, False, sim, samples, correctLogZero, probs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a6c6f046",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Level 5 Simulations ...\n",
      "Level 5 Simulations Complete\n"
     ]
    }
   ],
   "source": [
    "\"\"\" Level 5 Pauli X and Z Error Tests \"\"\"\n",
    "ccLevel5 = runThresholdCalculation(5, False, sim, samples, correctLogZero, probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb93d7b7",
   "metadata": {},
   "source": [
    "## Phenomenological Model Simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "3eaa6283",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Level 1 Simulations ...\n",
      "Level 1 Simulations Complete\n"
     ]
    }
   ],
   "source": [
    "\"\"\" Level 1 Pauli X and Z Error Tests \"\"\"\n",
    "phLevel1 = runThresholdCalculation(1, True, sim, samples, correctLogZero, probs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "942a038b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Level 2 Simulations ...\n",
      "Level 2 Simulations Complete\n"
     ]
    }
   ],
   "source": [
    "\"\"\" Level 2 Pauli X and Z Error Tests \"\"\"\n",
    "phLevel2 = runThresholdCalculation(2, True, sim, samples, correctLogZero, probs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "4a727e7e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Level 3 Simulations ...\n",
      "Level 3 Simulations Complete\n"
     ]
    }
   ],
   "source": [
    "\"\"\" Level 3 Pauli X and Z Error Tests \"\"\"\n",
    "phLevel3 = runThresholdCalculation(3, True, sim, samples, correctLogZero, probs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ef834e5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Level 4 Simulations ...\n",
      "Level 4 Simulations Complete\n"
     ]
    }
   ],
   "source": [
    "\"\"\" Level 4 Pauli X and Z Error Tests \"\"\"\n",
    "phLevel4 = runThresholdCalculation(4, True, sim, samples, correctLogZero, probs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d4739d8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Level 5 Simulations ...\n",
      "Level 5 Simulations Complete\n"
     ]
    }
   ],
   "source": [
    "\"\"\" Level 5 Pauli X and Z Error Tests \"\"\"\n",
    "phLevel5 = runThresholdCalculation(5, True, sim, samples, correctLogZero, probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08a8cfbb",
   "metadata": {},
   "source": [
    "## Code Capacity and Phenomenological Error Threshold Comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "5e7b5d3f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    " \"\"\" Code Capacity Simulations \"\"\"\n",
    "\n",
    "# Create Plot For Results\n",
    "fig = plt.figure(figsize = (15,5))\n",
    "plt.title('Pauli X and Z Error Threshold - Model: Code Capacity')\n",
    "plt.plot(probs, ccLevel1, label = 'Level 1')\n",
    "plt.plot(probs, ccLevel2, label = 'Level 2')\n",
    "plt.plot(probs, ccLevel3, label = 'Level 3')\n",
    "plt.plot(probs, ccLevel4, label = 'Level 4')\n",
    "plt.plot(probs, ccLevel5, label = 'Level 5')\n",
    "plt.plot(probs, probs, label = 'p')\n",
    "plt.xlabel('p')\n",
    "plt.ylabel('Logical p')\n",
    "plt.ylim([0,1.05])\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f4a2da0f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    " \"\"\" Phenomenological Simulations \"\"\"\n",
    "\n",
    "# Create Plot For Results\n",
    "fig = plt.figure(figsize = (15,5))\n",
    "plt.title('Pauli X and Z Error Threshold - Model: Phenomenological')\n",
    "plt.plot(probs, phLevel1, label = 'Level 1')\n",
    "plt.plot(probs, phLevel2, label = 'Level 2')\n",
    "plt.plot(probs, phLevel3, label = 'Level 3')\n",
    "plt.plot(probs, phLevel4, label = 'Level 4')\n",
    "plt.plot(probs, phLevel5, label = 'Level 5')\n",
    "plt.plot(probs, probs, label = 'p')\n",
    "plt.xlabel('p')\n",
    "plt.ylabel('Logical p')\n",
    "plt.ylim([0,1.05])\n",
    "plt.legend()\n",
    "plt.grid()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}