Witness_v1.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import copy\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from qiskit import QuantumRegister, ClassicalRegister\n",
        "from qiskit import QuantumCircuit, Aer, IBMQ, execute\n",
        "from qiskit.providers.aer import noise\n",
        "from qiskit.providers.aer.noise import NoiseModel\n",
        "from qiskit.tools.visualization import *\n",
        "from qiskit.tools.qi.qi import partial_trace, concurrence\n",
        "\n",
        "from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter, MeasurementFilter\n",
        "from qiskit.quantum_info import state_fidelity\n",
        "\n",
        "from qiskit.tools.monitor import job_monitor, backend_monitor, backend_overview"
      ],
      "outputs": [],
      "execution_count": 2,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "def local_measurement_circuits(input_circuit, qubit_list):\n",
        "    \n",
        "    ordered_qubit_list = sorted(qubit_list)\n",
        "    \n",
        "    cr = ClassicalRegister(len(qubit_list))\n",
        "    qr = input_circuit.qregs[0]\n",
        "    X = copy.deepcopy(input_circuit)\n",
        "    Y = copy.deepcopy(input_circuit)\n",
        "    Z = copy.deepcopy(input_circuit)\n",
        "    \n",
        "    X.add_register(cr)\n",
        "    Y.add_register(cr)\n",
        "    Z.add_register(cr)\n",
        "    \n",
        "    for bit_index in range(len(ordered_qubit_list)):\n",
        "        \n",
        "        qubit_index = ordered_qubit_list[bit_index]\n",
        "        \n",
        "        X.h(qr[qubit_index])\n",
        "        Y.sdg(qr[qubit_index])\n",
        "        Y.h(qr[qubit_index])\n",
        "        \n",
        "        X.measure(qr[qubit_index], cr[bit_index])\n",
        "        Y.measure(qr[qubit_index], cr[bit_index])\n",
        "        Z.measure(qr[qubit_index], cr[bit_index])\n",
        "    \n",
        "    return [X, Y, Z]"
      ],
      "outputs": [],
      "execution_count": 2,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "def W_minimizer(list_of_observables):\n",
        "    \"\"\"\n",
        "    W_minimizer accepts a list/array of five observables and returns the minimum of a general\n",
        "    W-function from arXiv:1901.08102v2, appendix A. \n",
        "    \"\"\"\n",
        "    observables = np.array(list_of_observables, dtype=np.float32)\n",
        "    \n",
        "    ## check if the input is correct.\n",
        "    assert len(list_of_observables)==5, \"List must contain 5 observables\"\n",
        "    for obs in observables:\n",
        "        assert -1 <= obs <= 1, \"Observable not in [-1,1]\"\n",
        "        \n",
        "    ## assign constants \n",
        "    # Form of W-function:\n",
        "    # W(a) = 1/4 (1 + b + (2a^2-1)*c + (2a^2-1)*d + 2*a*Sqrt(1-a^2)*(e+f))\n",
        "    \n",
        "    b, c, d, e, f = [obs for obs in observables]\n",
        "    \n",
        "    ## W-function:\n",
        "    w_a = lambda a: (1. + b + (c + d) * (2 * a**2 - 1) + (e + f) * (2 * a * np.sqrt(1 - a**2))) / 4.\n",
        "    #v_a = lambda a: (1.-b**2 + (1.-c**2 + 1.-d**2) * (2 * a**2 - 1)**2 + (1.-e**2 + 1.-f**2) * (2 * a * np.sqrt(1 - a**2))**2) / 4.\n",
        "    \n",
        "    ## minimum of W(a)-function w.r.t. \"a\" (from Mathematica)\n",
        "    w_min = lambda b, c, d, e, f: (1+b-np.sqrt((c+d)**2 + (e+f)**2)) / 4.\n",
        "    \n",
        "    ## argmin_a of w_min: (from Mathematica) \n",
        "    # defining auxillary constant \n",
        "    k = (c+d)**2 + (e+f)**2\n",
        "    \n",
        "    if k == 0:\n",
        "        a_min = 0\n",
        "    else:\n",
        "\n",
        "        a_min_root = np.sqrt((k - c * np.sqrt(k) - d * np.sqrt(k)) / (2 * k)) ## abs value of the argmin of the Minimize function\n",
        "        a_mins = [a_min_root, -a_min_root] ## take both since it is the absolute value of the argmin\n",
        "\n",
        "        a_min = a_mins[np.argmin([w_a(a_mins[0]),w_a(a_mins[1])])] \n",
        "        \n",
        "        if (a_min < -1) or (a_min > 1): ## check if a_min is out of boundary and print the corresponding parameters\n",
        "            print(\"Warning: a_min = \",str(a_min))\n",
        "            # print(b,c,d,e,f)\n",
        "    \n",
        "    #return \"Parameters: \", (b, c, d, e, f), \"Minimum: \", w_min(b,c,d,e,f), \"W(a_min): \", w_a(a_min), \"a_min: \", a_min\n",
        "    return w_a(a_min)#, v_a(a_min)/np.sqrt(8192)"
      ],
      "outputs": [],
      "execution_count": 3,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "def ComputeWitnessAllPairs(result, qubit_list):\n",
        "    \n",
        "    ordered_qubit_list = sorted(qubit_list)\n",
        "    nbits = len(ordered_qubit_list)\n",
        "    \n",
        "    counts = [result.get_counts(obs) for obs in range(3)]\n",
        "    \n",
        "    single_mean = {}\n",
        "    for bit_index in range(nbits):\n",
        "        qubit_index = ordered_qubit_list[bit_index]\n",
        "        single_mean[qubit_index] = {}\n",
        "        for obs in range(3):\n",
        "            nshots = 0\n",
        "            single_mean[qubit_index][obs] = 0.0\n",
        "            for outcome in counts[obs]:\n",
        "                if outcome[nbits-1-bit_index] == '0':\n",
        "                    single_mean[qubit_index][obs] += counts[obs][outcome]\n",
        "                else:\n",
        "                    single_mean[qubit_index][obs] -= counts[obs][outcome]\n",
        "                nshots += counts[obs][outcome]\n",
        "            single_mean[qubit_index][obs] = float(single_mean[qubit_index][obs])/float(nshots)\n",
        "    #print(single_mean)\n",
        "    \n",
        "    pairwise_mean = {}\n",
        "    for bit_index_i in range(nbits-1):\n",
        "        qubit_index_i = ordered_qubit_list[bit_index_i]\n",
        "        for bit_index_j in range(bit_index_i+1, nbits):\n",
        "            qubit_index_j = ordered_qubit_list[bit_index_j]\n",
        "            pair = (qubit_index_i, qubit_index_j)\n",
        "            pairwise_mean[pair] = {}\n",
        "            for obs in range(3):\n",
        "                nshots = 0\n",
        "                pairwise_mean[pair][obs] = 0.0\n",
        "                for outcome in counts[obs]:\n",
        "                    if outcome[nbits-1-bit_index_i] == outcome[nbits-1-bit_index_j]:\n",
        "                        pairwise_mean[pair][obs] += counts[obs][outcome]\n",
        "                    else:\n",
        "                        pairwise_mean[pair][obs] -= counts[obs][outcome]\n",
        "                    nshots += counts[obs][outcome]\n",
        "                pairwise_mean[pair][obs] = float(pairwise_mean[pair][obs])/float(nshots)\n",
        "    #print(pairwise_mean)\n",
        "\n",
        "\n",
        "    entanglement_witness = {}\n",
        "    for bit_index_i in range(nbits-1):\n",
        "        qubit_index_i = ordered_qubit_list[bit_index_i]\n",
        "        for bit_index_j in range(bit_index_i+1, nbits):\n",
        "            qubit_index_j = ordered_qubit_list[bit_index_j]\n",
        "            pair = (qubit_index_i, qubit_index_j)\n",
        "            \n",
        "            xi = single_mean[qubit_index_i][0]\n",
        "            ix = single_mean[qubit_index_j][0]\n",
        "            yi = single_mean[qubit_index_i][1]\n",
        "            iy = single_mean[qubit_index_j][1]\n",
        "            zi = single_mean[qubit_index_i][2]\n",
        "            iz = single_mean[qubit_index_j][2]\n",
        "            \n",
        "            xx = pairwise_mean[pair][0]\n",
        "            yy = pairwise_mean[pair][1]\n",
        "            zz = pairwise_mean[pair][2]\n",
        "\n",
        "            a = np.zeros((6,5))\n",
        "            a[0] = [zz, xx, yy, zi, iz]\n",
        "            a[1] = [-zz, xx, -yy, zi, -iz]\n",
        "            a[2] = [xx, zz, yy, xi, ix]\n",
        "            a[3] = [-xx, zz, -yy, -xi, ix]\n",
        "            a[4] = [yy, zz, xx, yi, iy]\n",
        "            a[5] = [-yy, zz, -xx, -yi, iy]\n",
        "\n",
        "            W_mins = [W_minimizer(a[i]) for i in range(6)]\n",
        "            #print(W_mins)\n",
        "            abs_min = min(W_mins)\n",
        "            entanglement_witness[pair] = (abs_min < -1.0/np.sqrt(float(nshots)), abs_min)\n",
        "    \n",
        "    return entanglement_witness"
      ],
      "outputs": [],
      "execution_count": 4,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "def GraphState(edges):\n",
        "    \n",
        "    qlist = []\n",
        "    for edge in edges:\n",
        "        if edge[0] not in qlist:\n",
        "            qlist.append(edge[0])\n",
        "        if edge[1] not in qlist:\n",
        "            qlist.append(edge[1])\n",
        "    \n",
        "    q = QuantumRegister(len(qlist))\n",
        "    graph = QuantumCircuit(q)\n",
        "    \n",
        "    for qubit_index in qlist:\n",
        "        graph.h(q[qubit_index])\n",
        "    \n",
        "    for edge in edges:\n",
        "        graph.h(q[edge[1]])\n",
        "        graph.cx(q[edge[0]], q[edge[1]])\n",
        "        graph.h(q[edge[1]])\n",
        "\n",
        "    return graph"
      ],
      "outputs": [],
      "execution_count": 5,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "def Darwin(n, l, t, theta):\n",
        "    \n",
        "    qr = QuantumRegister(2*n+1)\n",
        "    darwin = QuantumCircuit(qr)\n",
        "    \n",
        "    p = 1.0 - np.exp(-l*t)\n",
        "    phase = 2.0*np.arcsin(np.sqrt(p))\n",
        "    print(p,phase, np.sin(phase/2.0)**2)\n",
        "    \n",
        "    darwin.h(qr[2*n])\n",
        "    for emitter in range(0,2*n,2):\n",
        "        darwin.ry(phase, qr[emitter])\n",
        "        darwin.cx(qr[emitter], qr[emitter+1])\n",
        "        darwin.x(qr[emitter+1])\n",
        "        darwin.h(qr[emitter+1])\n",
        "        darwin.rz(-theta/2.0, qr[2*n])\n",
        "        darwin.rz(-theta/2.0, qr[emitter+1])\n",
        "        darwin.crz(theta/1.0, qr[2*n], qr[emitter+1])\n",
        "        darwin.crz(theta/1.0, qr[emitter+1], qr[2*n])\n",
        "        darwin.h(qr[emitter+1])\n",
        "    darwin.h(qr[2*n])\n",
        "    \n",
        "    return darwin"
      ],
      "outputs": [],
      "execution_count": 15,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "#q = QuantumRegister(5)\n",
        "#test_circ = QuantumCircuit(q)\n",
        "#test_circ.x(q[0])\n",
        "#test_circ.x(q[0])\n",
        "#test_circ.h(q[0])\n",
        "#test_circ.ry(0.05,q[0])\n",
        "#test_circ.h(q[0])\n",
        "#test_circ.s(q[0])\n",
        "#test_circ.cx(q[0],q[1])\n",
        "\n",
        "#test_circ = GraphState([(0,1), (1,2), (3,4), (4,5), (1,4)])\n",
        "#test_circ = GraphState([(0,1), (1,2), (0,2)])\n",
        "#test_circ = GraphState([(0,1)])\n",
        "#test_circ.h(test_circ.qregs[0][2])\n",
        "\n",
        "test_circ = Darwin(1, 10., 1.0, 1.0*np.pi/1.30)\n",
        "qlist = list(range(len(test_circ.qregs[0])))\n",
        "#lmc = local_measurement_circuits(test_circ, qlist)\n",
        "\n",
        "test_circ.draw(output = 'mpl')\n"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.9999546000702375 3.1281166576221096 0.9999546000702376\n"
          ]
        },
        {
          "output_type": "execute_result",
          "execution_count": 16,
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 662.2x198.66 with 1 Axes>"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 16,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "job_state_vec = execute(test_circ, Aer.get_backend('statevector_simulator'))\n",
        "state_vec = job_state_vec.result().get_statevector()\n",
        "\n",
        "conc = {}\n",
        "n = len(qlist)\n",
        "for i in range(n-1):\n",
        "    for j in range(i+1, n):\n",
        "        qpt = qlist[:]\n",
        "        qpt.remove(i)\n",
        "        qpt.remove(j)\n",
        "        part = partial_trace(state_vec, qpt)\n",
        "        conc[(i,j)] = (concurrence(part) > 1e-5, concurrence(part))\n",
        "conc"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 17,
          "data": {
            "text/plain": [
              "{(0, 1): (True, 0.09943009484123723),\n",
              " (0, 2): (True, 0.056259221960011055),\n",
              " (1, 2): (True, 0.8941248102156978)}"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 17,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "nshots = 8192\n",
        "backend = Aer.get_backend('qasm_simulator')\n",
        "job = execute(lmc, backend=backend, shots = nshots)\n",
        "job_result = job.result()\n",
        "ComputeWitnessAllPairs(job_result, qlist)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "print(job_result.get_counts(2))"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "def W_a(av, a):\n",
        "    \n",
        "    return 0.25*(1.0 + av[0] + (av[1] + av[2])*(2.0*a**2-1.0) + (av[3]+av[4])*(2.0*a*np.sqrt(1.0-a**2)))\n",
        "\n",
        "ix, xi = 0.,0.\n",
        "iy, yi = 0.,0.\n",
        "iz, zi = 0.,0.\n",
        "xx = -1.\n",
        "yy = -1.\n",
        "zz = -1.\n",
        "\n",
        "al = np.zeros((6,5))\n",
        "al[0] = [zz, xx, yy, zi, iz]\n",
        "al[1] = [-zz, xx, -yy, zi, -iz]\n",
        "al[2] = [xx, zz, yy, xi, ix]\n",
        "al[3] = [-xx, zz, -yy, -xi, ix]\n",
        "al[4] = [yy, zz, xx, yi, iy]\n",
        "al[5] = [-yy, zz, -xx, -yi, iy]\n",
        "\n",
        "a_vals = np.linspace(-1.0, 1.0, 100)\n",
        "for i in range(6):\n",
        "    y_vals = W_a(al[i], a_vals)\n",
        "    plt.plot(a_vals, y_vals, label = str(i))\n",
        "plt.legend()"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "from qiskit.tools.qi.qi import concurrence"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "concurrence(np.array([1.,0.,0.,-1.]/np.sqrt(2.0)))"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "N = 1000\n",
        "nlayers = int(np.ceil(np.log(float(N))/np.log(3.0)))\n",
        "print(nlayers)\n",
        "pairs = {}\n",
        "obs = [\"X\", \"Y\", \"Z\"]\n",
        "for one in range(3):\n",
        "    for two in range(2):\n",
        "        obs_copy = obs[:]\n",
        "        sequence = [obs_copy[one]]\n",
        "        obs_copy.remove(obs_copy[one])\n",
        "        sequence.append(obs_copy[two])\n",
        "        obs_copy.remove(obs_copy[two])\n",
        "        sequence.append(obs_copy[0])\n",
        "        \n",
        "        for layout in range(nlayers):\n",
        "            c = {}\n",
        "            for qubit in range(N):\n",
        "                q_index = int(float(qubit)/float(3**layout))%3\n",
        "                c[qubit] = sequence[q_index]\n",
        "        \n",
        "            for i in range(N-1):\n",
        "                q_index_i = int(float(i)/float(3**layout))%3\n",
        "                for j in range(i+1,N):\n",
        "                    q_index_j = int(float(j)/float(3**layout))%3\n",
        "                    pair = (i,j)\n",
        "                    if pair not in pairs:\n",
        "                        pairs[pair] = []\n",
        "                    if q_index_i != q_index_j and (c[i],c[j]) not in pairs[pair]:\n",
        "                        pairs[pair].append((c[i],c[j]))\n",
        "\n"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "pos = [('X','Y'),('X','Z'),('Y','X'),('Y','Z'),('Z','X'),('Z','Y')]\n",
        "for pair in pairs:\n",
        "    if len(pairs[pair]) != 6:\n",
        "        print(\"Length error\", pair)\n",
        "    pos_copy = pos[:]\n",
        "    for el in pairs[pair]:\n",
        "        pos_copy.remove(el)\n",
        "    if len(pos_copy) > 0:\n",
        "        print(\"Oops\", pair)\n",
        "    "
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "pairs"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "def pairwise_state_tomography_circuits(input_circuit, qubit_list):\n",
        "    \n",
        "    ### Initialisation stuff\n",
        "    ordered_qubit_list = sorted(qubit_list)\n",
        "    N = len(qubit_list)\n",
        "    \n",
        "    cr = ClassicalRegister(len(qubit_list))\n",
        "    qr = input_circuit.qregs[0]\n",
        "    \n",
        "    \n",
        "    ### Uniform measurement settings\n",
        "    X = copy.deepcopy(input_circuit)\n",
        "    Y = copy.deepcopy(input_circuit)\n",
        "    Z = copy.deepcopy(input_circuit)\n",
        "    \n",
        "    X.add_register(cr)\n",
        "    Y.add_register(cr)\n",
        "    Z.add_register(cr)\n",
        "    \n",
        "    X.name = ('X',)*N\n",
        "    Y.name = ('Y',)*N\n",
        "    Z.name = ('Z',)*N\n",
        "    \n",
        "    for bit_index in range(len(ordered_qubit_list)):\n",
        "        \n",
        "        qubit_index = ordered_qubit_list[bit_index]\n",
        "        \n",
        "        X.h(qr[qubit_index])\n",
        "        Y.sdg(qr[qubit_index])\n",
        "        Y.h(qr[qubit_index])\n",
        "        \n",
        "        X.measure(qr[qubit_index], cr[bit_index])\n",
        "        Y.measure(qr[qubit_index], cr[bit_index])\n",
        "        Z.measure(qr[qubit_index], cr[bit_index])\n",
        "    \n",
        "    output_circuit_list = [X, Y, Z]\n",
        "    \n",
        "    \n",
        "    ### Heterogeneous measurement settings\n",
        "    # Generation of six possible sequences\n",
        "    sequences = []\n",
        "    meas_bases = ['X', 'Y', 'Z']\n",
        "    for i in range(3):\n",
        "        for j in range(2):\n",
        "            meas_bases_copy = meas_bases[:]\n",
        "            sequence = [meas_bases_copy[i]]\n",
        "            meas_bases_copy.remove(meas_bases_copy[i])\n",
        "            sequence.append(meas_bases_copy[j])\n",
        "            meas_bases_copy.remove(meas_bases_copy[j])\n",
        "            sequence.append(meas_bases_copy[0])\n",
        "            sequences.append(sequence)\n",
        "    \n",
        "    # Qubit colouring\n",
        "    nlayers = int(np.ceil(np.log(float(N))/np.log(3.0)))\n",
        "    pairs = {}\n",
        "    for layout in range(nlayers):\n",
        "        for sequence in sequences:\n",
        "            meas_layout = copy.deepcopy(input_circuit)\n",
        "            meas_layout.add_register(cr)\n",
        "            meas_layout.name = ()\n",
        "            for bit_index in range(N):\n",
        "                qubit_index = ordered_qubit_list[bit_index]\n",
        "                local_basis = sequence[int(float(bit_index)/float(3**layout))%3]\n",
        "                if local_basis == 'Y':\n",
        "                    meas_layout.sdg(qr[qubit_index])\n",
        "                if local_basis != 'Z':\n",
        "                    meas_layout.h(qr[qubit_index])\n",
        "                meas_layout.measure(qr[qubit_index], cr[bit_index])\n",
        "                meas_layout.name += (local_basis,)\n",
        "            output_circuit_list.append(meas_layout)\n",
        "    \n",
        "    return output_circuit_list"
      ],
      "outputs": [],
      "execution_count": 3,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "q = QuantumRegister(20)\n",
        "test_circ = QuantumCircuit(q)\n",
        "qlist = list(range(20))\n",
        "\n",
        "meas_circs = pairwise_state_tomography_circuits(test_circ, qlist)"
      ],
      "outputs": [],
      "execution_count": 11,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "for i, c in enumerate(meas_circs):\n",
        "    print(i,c.name)\n",
        "    print(\"#\"*40)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 ('X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X')\n",
            "########################################\n",
            "1 ('Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y')\n",
            "########################################\n",
            "2 ('Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z')\n",
            "########################################\n",
            "3 ('X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y')\n",
            "########################################\n",
            "4 ('X', 'Z', 'Y', 'X', 'Z', 'Y', 'X', 'Z', 'Y', 'X', 'Z', 'Y', 'X', 'Z', 'Y', 'X', 'Z', 'Y', 'X', 'Z')\n",
            "########################################\n",
            "5 ('Y', 'X', 'Z', 'Y', 'X', 'Z', 'Y', 'X', 'Z', 'Y', 'X', 'Z', 'Y', 'X', 'Z', 'Y', 'X', 'Z', 'Y', 'X')\n",
            "########################################\n",
            "6 ('Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z')\n",
            "########################################\n",
            "7 ('Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z', 'X')\n",
            "########################################\n",
            "8 ('Z', 'Y', 'X', 'Z', 'Y', 'X', 'Z', 'Y', 'X', 'Z', 'Y', 'X', 'Z', 'Y', 'X', 'Z', 'Y', 'X', 'Z', 'Y')\n",
            "########################################\n",
            "9 ('X', 'X', 'X', 'Y', 'Y', 'Y', 'Z', 'Z', 'Z', 'X', 'X', 'X', 'Y', 'Y', 'Y', 'Z', 'Z', 'Z', 'X', 'X')\n",
            "########################################\n",
            "10 ('X', 'X', 'X', 'Z', 'Z', 'Z', 'Y', 'Y', 'Y', 'X', 'X', 'X', 'Z', 'Z', 'Z', 'Y', 'Y', 'Y', 'X', 'X')\n",
            "########################################\n",
            "11 ('Y', 'Y', 'Y', 'X', 'X', 'X', 'Z', 'Z', 'Z', 'Y', 'Y', 'Y', 'X', 'X', 'X', 'Z', 'Z', 'Z', 'Y', 'Y')\n",
            "########################################\n",
            "12 ('Y', 'Y', 'Y', 'Z', 'Z', 'Z', 'X', 'X', 'X', 'Y', 'Y', 'Y', 'Z', 'Z', 'Z', 'X', 'X', 'X', 'Y', 'Y')\n",
            "########################################\n",
            "13 ('Z', 'Z', 'Z', 'X', 'X', 'X', 'Y', 'Y', 'Y', 'Z', 'Z', 'Z', 'X', 'X', 'X', 'Y', 'Y', 'Y', 'Z', 'Z')\n",
            "########################################\n",
            "14 ('Z', 'Z', 'Z', 'Y', 'Y', 'Y', 'X', 'X', 'X', 'Z', 'Z', 'Z', 'Y', 'Y', 'Y', 'X', 'X', 'X', 'Z', 'Z')\n",
            "########################################\n",
            "15 ('X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Z', 'Z')\n",
            "########################################\n",
            "16 ('X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Y', 'Y')\n",
            "########################################\n",
            "17 ('Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'Z', 'Z')\n",
            "########################################\n",
            "18 ('Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'X', 'X')\n",
            "########################################\n",
            "19 ('Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'Y', 'Y')\n",
            "########################################\n",
            "20 ('Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'X', 'X')\n",
            "########################################\n"
          ]
        }
      ],
      "execution_count": 12,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "meas_circs[12].draw(output='mpl')"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 13,
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 1502.59x1288.28 with 1 Axes>"
            ]
          },
          "metadata": {}
        }
      ],
      "execution_count": 13,
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [],
      "outputs": [],
      "execution_count": null,
      "metadata": {}
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "language": "python",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python",
      "version": "3.7.4",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "kernel_info": {
      "name": "python3"
    },
    "nteract": {
      "version": "0.15.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}