| Qiskit Software | Version |
|---|---|
| Qiskit | 0.19.6 |
| Terra | 0.14.2 |
| Aer | 0.5.2 |
| Ignis | 0.3.3 |
| Aqua | 0.7.3 |
| IBM Q Provider | 0.7.2 |
| System information | |
| Python | 3.7.6 (default, Jan 8 2020, 20:23:39) [MSC v.1916 64 bit (AMD64)] |
| OS | Windows |
| CPUs | 2 |
| Memory (Gb) | 7.886066436767578 |
| Wed Aug 12 14:54:09 2020 Hora de Verão de GMT | |
┌──────┐┌────┐┌───────────┐ ░ ┌────┐ ░ ┌─┐ \n", + "q_0: |0>┤0 ├┤0 ├┤ RZ(-pi/2) ├─░───────────┤0 ├───────────░─┤M├─────────\n", + " │ B_1 ││ F │└───────────┘ ░ ┌────────┐│ F │┌────────┐ ░ └╥┘┌─┐ \n", + "q_1: |0>┤1 ├┤1 ├──────────────░─┤0 ├┤1 ├┤0 ├─░──╫─┤M├──────\n", + " └──────┘├────┤ ░ │ FSWAP │├────┤│ FSWAP │ ░ ║ └╥┘┌─┐ \n", + "q_2: |0>────────┤0 ├──────────────░─┤1 ├┤0 ├┤1 ├─░──╫──╫─┤M├───\n", + " ┌───┐ │ F │ ░ └────────┘│ F │└────────┘ ░ ║ ║ └╥┘┌─┐\n", + "q_3: |0>─┤ X ├──┤1 ├──────────────░───────────┤1 ├───────────░──╫──╫──╫─┤M├\n", + " └───┘ └────┘ ░ └────┘ ░ ║ ║ ║ └╥┘\n", + " c: 0 4/════════════════════════════════════════════════════════════╩══╩══╩══╩═\n", + " 0 1 2 3" + ], + "text/plain": [ + " ┌──────┐┌────┐┌───────────┐ ░ ┌────┐ ░ ┌─┐ \n", + "q_0: |0>┤0 ├┤0 ├┤ RZ(-pi/2) ├─░───────────┤0 ├───────────░─┤M├─────────\n", + " │ B_1 ││ F │└───────────┘ ░ ┌────────┐│ F │┌────────┐ ░ └╥┘┌─┐ \n", + "q_1: |0>┤1 ├┤1 ├──────────────░─┤0 ├┤1 ├┤0 ├─░──╫─┤M├──────\n", + " └──────┘├────┤ ░ │ FSWAP │├────┤│ FSWAP │ ░ ║ └╥┘┌─┐ \n", + "q_2: |0>────────┤0 ├──────────────░─┤1 ├┤0 ├┤1 ├─░──╫──╫─┤M├───\n", + " ┌───┐ │ F │ ░ └────────┘│ F │└────────┘ ░ ║ ║ └╥┘┌─┐\n", + "q_3: |0>─┤ X ├──┤1 ├──────────────░───────────┤1 ├───────────░──╫──╫──╫─┤M├\n", + " └───┘ └────┘ ░ └────┘ ░ ║ ║ ║ └╥┘\n", + " c: 0 4/════════════════════════════════════════════════════════════╩══╩══╩══╩═\n", + " 0 1 2 3 " + ] + }, + "execution_count": 111, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# This circuit can be implemented in ibmqx5 using qubits (q0,q1,q2,q3)=(6,7,11,10)\n", - "# It can also be implemented between other qubits or in ibqmx2 and ibqmx4 using fermionic SWAPS\n", - "# For instance, the lines commented correspond to the implementations:\n", - "# ibmqx2 (q0,q1,q2,q3)=(4,2,0,1)\n", - "# ibmqx4 (q0,q1,q2,q3)=(3,2,1,0)\n", - "def Udisg(qc,lam,q0,q1,q2,q3):\n", - " k=1\n", - " n=4\n", - " th1=-np.arccos((lam-np.cos(2*pi*k/n))/np.sqrt((lam-np.cos(2*pi*k/n))**2+np.sin(2*pi*k/n)**2))\n", - " B(Udis,th1,q0,q1)\n", - " F1(Udis,q0,q1)\n", - " F0(Udis,q2,q3)\n", - " #fSWAP(Udis,q2,q1) # for ibmqx2\n", - " #fSWAP(Udis,q1,q2) # for ibmqx4\n", - " F0(Udis,q0,q2)\n", - " F0(Udis,q1,q3)\n", - " #fSWAP(Udis,q2,q1) # for ibmqx2\n", - " #fSWAP(Udis,q1,q2) # for ibmqx4\n", - "\n", - "def Initial(qc,lam,q0,q1,q2,q3):\n", - " if lam <1:\n", - " qc.x(q3)\n", - "\n", - "def Ising(qc,ini,udis,mes,lam,q0,q1,q2,q3,c0,c1,c2,c3):\n", - " Initial(ini,lam,q0,q1,q2,q3)\n", - " Udisg(udis,lam,q0,q1,q2,q3)\n", - " mes.measure(q0,c0)\n", - " mes.measure(q1,c1)\n", - " mes.measure(q2,c2)\n", - " mes.measure(q3,c3)\n", - " qc.add_circuit(\"Ising\",ini+udis+mes)" + "def get_circ(lam, barriers=True, with_initial=True):\n", + " circuit = QuantumCircuit(4, 4)\n", + " \n", + " if with_initial:\n", + " if lam < 1:\n", + " circuit.x(3)\n", + "\n", + " circuit.append(bog(lam, k=1), [0, 1])\n", + "\n", + " circuit.append(F(), [0, 1])\n", + " circuit.rz(-2*np.pi/4*1, 0) # twiddle factor\n", + " circuit.append(F(), [2, 3])\n", + " if barriers:\n", + " circuit.barrier()\n", + " circuit.append(fswap(), [1, 2])\n", + " circuit.append(F(), [0, 1])\n", + " circuit.append(F(), [2, 3])\n", + " circuit.append(fswap(), [1, 2])\n", + " \n", + " if barriers:\n", + " circuit.barrier()\n", + " circuit.measure(0, 0)\n", + " circuit.measure(1, 1)\n", + " circuit.measure(2, 2)\n", + " circuit.measure(3, 3)\n", + "\n", + " return circuit\n", + "\n", + "\n", + "get_circ(0.25).draw(output=\"text\", fold=2000, vertical_compression=\"high\", initial_state=True, cregbundle=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are now ready to simulate our system. We start with the qasm simulator:" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done\n" + ] + } + ], "source": [ - "#import sys \n", - "#sys.path.append(\"../../\") \n", - "# importing the QISKit\n", - "from qiskit import QuantumCircuit,QuantumProgram\n", - "#import Qconfig \n", - "# useful additional packages\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "import numpy as np\n", - "from scipy import linalg as la" + "mag_sim=[]\n", + "lam_values=np.linspace(0,2,15)\n", + "qasm=Aer.get_backend(\"qasm_simulator\")\n", + "shots=2048\n", + "for lam in lam_values:\n", + " qc = get_circ(lam)\n", + " result = execute(qc, backend=qasm, shots=shots).result()\n", + " res = result.get_counts()\n", + " r1 = list(res.keys())\n", + " r2 = list(res.values())\n", + " M = 0\n", + " for j in range(0, len(r1)):\n", + " M = M+(4-2*digit_sum(r1[j]))*r2[j]/shots\n", + " mag_sim.append(M/4)\n", + "print(\"Done\")" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
┌───┐ ┌───┐ ┌───┐ ┌───┐┌───┐┌───┐┌───┐┌───────────┐ ┌───┐ ┌───┐┌───┐┌───┐┌───┐ ┌─┐ \n", + "q_0: |0>───────────────┤ X ├────────────────────────────────────■────────────────────────■──────────────┤ X ├─────┤ X ├─────────────────────■─────────────────┤ X ├┤ H ├┤ X ├┤ H ├┤ U1(-pi/2) ├───────────────┤ X ├────────────────────────■──────────────────┤ X ├┤ H ├┤ X ├┤ H ├─────┤M├────────────────────────────────────\n", + " ┌───┐ └─┬─┘┌───────────┐┌──────────────────┐ ┌─┴─┐ ┌─────────────────┐┌─┴─┐┌──────────┐└─┬─┘┌───┐└─┬─┘┌─────┐┌───┐┌─────┐┌─┴─┐┌───┐┌───┐┌───┐└─┬─┘└───┘└─┬─┘└───┘└───┬───┬───┘ └─┬─┘┌─────┐ ┌───┐ ┌─────┐ ┌─┴─┐ ┌───┐┌───┐┌───┐└─┬─┘└───┘└─┬─┘└───┘ └╥┘ ┌───┐ ┌─┐ \n", + "q_1: |0>─────┤ X ├───────■──┤ U1(-pi/2) ├┤ U3(-0.66291,0,0) ├─┤ X ├─┤ U3(0.66291,0,0) ├┤ X ├┤ U1(pi/2) ├──■──┤ X ├──■──┤ SDG ├┤ H ├┤ TDG ├┤ X ├┤ T ├┤ H ├┤ S ├──■─────────■────■──────┤ X ├──────■─────────■────■──┤ SDG ├─┤ H ├─┤ TDG ├─┤ X ├─┤ T ├┤ H ├┤ S ├──■─────────■─────────────╫───■──┤ X ├──■─────────■───────┤M├───\n", + " └───┘ ┌───┐└───────────┘└──────────────────┘ └───┘ └─────────────────┘└───┘└──────────┘ ├───┤┌───┐└┬───┬┘├───┤└─────┘└───┘└───┘└───┘└───┘ ┌─┴─┐ └─┬─┘ ┌─┴─┐┌───┐┌─┴─┐┌───┐└┬───┬┘ └───┘ └─────┘ └───┘ └───┘└───┘└───┘ ┌───┐┌───┐┌───┐┌───┐ ║ ┌─┴─┐└─┬─┘┌─┴─┐┌───┐┌─┴─┐┌───┐└╥┘┌─┐\n", + "q_2: |0>───────────────┤ X ├─────────────────────────────────────────────────■───────────────────────────────┤ X ├┤ H ├─┤ X ├─┤ H ├──────────────────────────────────────────┤ X ├──────■──────┤ X ├┤ H ├┤ X ├┤ H ├─┤ X ├────────────────────────■─────────────────┤ X ├┤ H ├┤ X ├┤ H ├─╫─┤ X ├──■──┤ X ├┤ H ├┤ X ├┤ H ├─╫─┤M├\n", + " ┌─────────────┐└─┬─┘ ┌─────┐ ┌───┐ ┌─────┐ ┌─┴─┐ ┌───┐ ┌───┐ ┌───┐└─┬─┘└───┘ └─┬─┘ └───┘ └───┘ └───┘└───┘└───┘└───┘ └─┬─┘ ┌─────┐ ┌───┐ ┌─────┐┌─┴─┐┌───┐┌───┐┌───┐└─┬─┘└───┘└─┬─┘└┬─┬┘ ║ └───┘ └───┘└───┘└───┘└───┘ ║ └╥┘\n", + "q_3: |0>┤ U3(pi,0,pi) ├──■─────┤ SDG ├──────────┤ H ├────────┤ TDG ├───────┤ X ├───────┤ T ├───┤ H ├────┤ S ├──■──────────■───────────────────────────────────────────────────────────────────────────────────────────■───┤ SDG ├─┤ H ├─┤ TDG ├┤ X ├┤ T ├┤ H ├┤ S ├──■─────────■───┤M├──╫────────────────────────────────╫──╫─\n", + " └─────────────┘ └─────┘ └───┘ └─────┘ └───┘ └───┘ └───┘ └───┘ └─────┘ └───┘ └─────┘└───┘└───┘└───┘└───┘ └╥┘ ║ ║ ║ \n", + " c: 0 4/════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╩═══╩════════════════════════════════╩══╩═\n", + " 3 0 1 2" + ], "text/plain": [ - "
┌──────────────────────┐ ┌────────────────────┐ ┌───────────┐ ┌───────────────────┐ ┌──────────────┐ ┌─┐ \n", + " q_0 -> 0 |0>┤ U3(pi/2,3pi/2,-pi/4) ├──■──┤ U3(3.0191,0,3pi/2) ├──■────────┤ U1(3pi/2) ├───────────────────────────────────────────────────────■──┤ U3(3pi/4,0,3pi/2) ├──■──────┤ U2(3pi/4,pi) ├────────┤M├──────────────────────────────────────\n", + " └──┬────────────────┬──┘┌─┴─┐├───────────────────┬┘┌─┴─┐┌─────┴───────────┴─────┐ ┌─────────────┐ ┌────────────────────┐┌─┴─┐└─┬────────────────┬┘┌─┴─┐ ┌──┴──────────────┴─┐ └╥┘┌─────────────┐ ┌─────────────┐┌─┐\n", + " q_1 -> 1 |0>───┤ U2(pi/2,5pi/4) ├───┤ X ├┤ U2(3pi/2,0.12249) ├─┤ X ├┤ U3(pi/2,3pi/2,2.1196) ├──■──┤ U2(0,3pi/2) ├──■──┤ U3(2.1196,pi,pi/2) ├┤ X ├──┤ U2(3pi/2,pi/4) ├─┤ X ├─┤ U2(3pi/2,0.54878) ├───■───╫─┤ U2(0,3pi/2) ├──■──┤ U2(4.949,0) ├┤M├\n", + " ┌─┴────────────────┴┐ └───┘├───────────────────┤ └───┘└┬─────────────────────┬┘┌─┴─┐├─────────────┤┌─┴─┐├───────────────────┬┘└───┘┌─┴────────────────┴┐└───┘┌┴───────────────────┴┐┌─┴─┐ ║ ├─────────────┤┌─┴─┐└─────┬─┬─────┘└╥┘\n", + " q_2 -> 2 |0>─┤ U2(pi/2,-0.66453) ├────■──┤ U3(3pi/4,0,3pi/2) ├───■───┤ U3(2.7137,2pi,pi/2) ├─┤ X ├┤ U2(3pi/2,0) ├┤ X ├┤ U2(-pi/2,-2.5928) ├───■──┤ U3(3pi/4,0,3pi/2) ├──■──┤ U3(1.022,2pi,3pi/2) ├┤ X ├─╫─┤ U2(3pi/2,0) ├┤ X ├──────┤M├───────╫─\n", + " └┬──────────────────┤ ┌─┴─┐└─┬────────────────┬┘ ┌─┴─┐ └─┬──────────────────┬┘ └───┘└─────────────┘└───┘└───────────────────┘ ┌─┴─┐└─┬────────────────┬┘┌─┴─┐├─────────────────────┤└┬─┬┘ ║ └─────────────┘└───┘ └╥┘ ║ \n", + " q_3 -> 3 |0>──┤ U2(pi/2,-4.0479) ├──┤ X ├──┤ U2(3pi/2,pi/4) ├──┤ X ├───┤ U2(pi/2,-3.2625) ├─────────────────────────────────────────────────┤ X ├──┤ U2(3pi/2,pi/4) ├─┤ X ├┤ U3(pi,-3pi/2,-pi/4) ├─┤M├──╫────────────────────────────╫────────╫─\n", + " └──────────────────┘ └───┘ └────────────────┘ └───┘ └──────────────────┘ └───┘ └────────────────┘ └───┘└─────────────────────┘ └╥┘ ║ ║ ║ \n", + "ancilla_0 -> 4 |0>────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╫───╫────────────────────────────╫────────╫─\n", + " ║ ║ ║ ║ \n", + " c: 0 4/════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╩═══╩════════════════════════════╩════════╩═\n", + " 3 0 2 1" + ], + "text/plain": [ + " ┌──────────────────────┐ ┌────────────────────┐ ┌───────────┐ ┌───────────────────┐ ┌──────────────┐ ┌─┐ \n", + " q_0 -> 0 |0>┤ U3(pi/2,3pi/2,-pi/4) ├──■──┤ U3(3.0191,0,3pi/2) ├──■────────┤ U1(3pi/2) ├───────────────────────────────────────────────────────■──┤ U3(3pi/4,0,3pi/2) ├──■──────┤ U2(3pi/4,pi) ├────────┤M├──────────────────────────────────────\n", + " └──┬────────────────┬──┘┌─┴─┐├───────────────────┬┘┌─┴─┐┌─────┴───────────┴─────┐ ┌─────────────┐ ┌────────────────────┐┌─┴─┐└─┬────────────────┬┘┌─┴─┐ ┌──┴──────────────┴─┐ └╥┘┌─────────────┐ ┌─────────────┐┌─┐\n", + " q_1 -> 1 |0>───┤ U2(pi/2,5pi/4) ├───┤ X ├┤ U2(3pi/2,0.12249) ├─┤ X ├┤ U3(pi/2,3pi/2,2.1196) ├──■──┤ U2(0,3pi/2) ├──■──┤ U3(2.1196,pi,pi/2) ├┤ X ├──┤ U2(3pi/2,pi/4) ├─┤ X ├─┤ U2(3pi/2,0.54878) ├───■───╫─┤ U2(0,3pi/2) ├──■──┤ U2(4.949,0) ├┤M├\n", + " ┌─┴────────────────┴┐ └───┘├───────────────────┤ └───┘└┬─────────────────────┬┘┌─┴─┐├─────────────┤┌─┴─┐├───────────────────┬┘└───┘┌─┴────────────────┴┐└───┘┌┴───────────────────┴┐┌─┴─┐ ║ ├─────────────┤┌─┴─┐└─────┬─┬─────┘└╥┘\n", + " q_2 -> 2 |0>─┤ U2(pi/2,-0.66453) ├────■──┤ U3(3pi/4,0,3pi/2) ├───■───┤ U3(2.7137,2pi,pi/2) ├─┤ X ├┤ U2(3pi/2,0) ├┤ X ├┤ U2(-pi/2,-2.5928) ├───■──┤ U3(3pi/4,0,3pi/2) ├──■──┤ U3(1.022,2pi,3pi/2) ├┤ X ├─╫─┤ U2(3pi/2,0) ├┤ X ├──────┤M├───────╫─\n", + " └┬──────────────────┤ ┌─┴─┐└─┬────────────────┬┘ ┌─┴─┐ └─┬──────────────────┬┘ └───┘└─────────────┘└───┘└───────────────────┘ ┌─┴─┐└─┬────────────────┬┘┌─┴─┐├─────────────────────┤└┬─┬┘ ║ └─────────────┘└───┘ └╥┘ ║ \n", + " q_3 -> 3 |0>──┤ U2(pi/2,-4.0479) ├──┤ X ├──┤ U2(3pi/2,pi/4) ├──┤ X ├───┤ U2(pi/2,-3.2625) ├─────────────────────────────────────────────────┤ X ├──┤ U2(3pi/2,pi/4) ├─┤ X ├┤ U3(pi,-3pi/2,-pi/4) ├─┤M├──╫────────────────────────────╫────────╫─\n", + " └──────────────────┘ └───┘ └────────────────┘ └───┘ └──────────────────┘ └───┘ └────────────────┘ └───┘└─────────────────────┘ └╥┘ ║ ║ ║ \n", + "ancilla_0 -> 4 |0>────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╫───╫────────────────────────────╫────────╫─\n", + " ║ ║ ║ ║ \n", + " c: 0 4/════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╩═══╩════════════════════════════╩════════╩═\n", + " 3 0 2 1 " + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "## Time evolution\n", - "\n", + "circuit_transpiled = transpile(get_circ(0.25, barriers=False), backend=device, optimization_level=3)\n", + "print(\"Operations: \", circuit_transpiled.count_ops())\n", + "print(\"Total number of gates: \", circuit_transpiled.size())\n", + "print(\"Depth: \", circuit_transpiled.depth())\n", + "print(\"Number of gates removed: \", qc.decompose().size()-circuit_transpiled.size())\n", + "circuit_transpiled.draw(output=\"text\", fold=2000,\n", + " vertical_compression=\"high\", initial_state=True, cregbundle=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Having optimized our circuit, we move on to the next part: error mitigation. When running on an actual device, errors are inevitable, however we can try to mitigate some of the measurement errors as is explained [here](https://qiskit.org/textbook/ch-quantum-hardware/measurement-error-mitigation.html). Notice also that it requires $2^N$ gates to get a calibration matrix. Since here we only have 4 qubits it is fairly easy to do so, but for greater systems it may be expensive." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "26661db0214e46779ef433f507d54025", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Accordion(children=(VBox(layout=Layout(max_width='710px', min_width='710px')),), layout=Layout(max_height='500…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "$('div.job_widget')\n", + " .detach()\n", + " .appendTo($('#header'))\n", + " .css({\n", + " 'z-index': 999,\n", + " 'position': 'fixed',\n", + " 'box-shadow': '5px 5px 5px -3px black',\n", + " 'opacity': 0.95,\n", + " 'float': 'left,'\n", + " })\n", + " " + ], + "text/plain": [ + "
| Type | Gate error | |
|---|---|---|
| cx2_1 | cx | 0.00697 |
| cx2_3 | cx | 0.00797 |
| cx3_2 | cx | 0.00797 |
| sample_name | Snake |
| qubit_lo_range | [[4333430597.562168, 5333430597.562168], [4123852322.963768, 5123852322.963768], [4320531275.264617, 5320531275.264617], [4242331971.9375987, 5242331971.937599], [4316318056.924669, 5316318056.924669]] |
| open_pulse | False |
| conditional_latency | [] |
| coupling_map | [[0, 1], [1, 0], [1, 2], [2, 1], [2, 3], [3, 2], [3, 4], [4, 3]] |
| channels | {'acquire0': {'operates': {'qubits': [0]}, 'purpose': 'acquire', 'type': 'acquire'}, 'acquire1': {'operates': {'qubits': [1]}, 'purpose': 'acquire', 'type': 'acquire'}, 'acquire2': {'operates': {'qubits': [2]}, 'purpose': 'acquire', 'type': 'acquire'}, 'acquire3': {'operates': {'qubits': [3]}, 'purpose': 'acquire', 'type': 'acquire'}, 'acquire4': {'operates': {'qubits': [4]}, 'purpose': 'acquire', 'type': 'acquire'}, 'd0': {'operates': {'qubits': [0]}, 'purpose': 'drive', 'type': 'drive'}, 'd1': {'operates': {'qubits': [1]}, 'purpose': 'drive', 'type': 'drive'}, 'd2': {'operates': {'qubits': [2]}, 'purpose': 'drive', 'type': 'drive'}, 'd3': {'operates': {'qubits': [3]}, 'purpose': 'drive', 'type': 'drive'}, 'd4': {'operates': {'qubits': [4]}, 'purpose': 'drive', 'type': 'drive'}, 'm0': {'operates': {'qubits': [0]}, 'purpose': 'measure', 'type': 'measure'}, 'm1': {'operates': {'qubits': [1]}, 'purpose': 'measure', 'type': 'measure'}, 'm2': {'operates': {'qubits': [2]}, 'purpose': 'measure', 'type': 'measure'}, 'm3': {'operates': {'qubits': [3]}, 'purpose': 'measure', 'type': 'measure'}, 'm4': {'operates': {'qubits': [4]}, 'purpose': 'measure', 'type': 'measure'}, 'u0': {'operates': {'qubits': [0, 1]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u1': {'operates': {'qubits': [1, 0]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u2': {'operates': {'qubits': [1, 2]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u3': {'operates': {'qubits': [2, 1]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u4': {'operates': {'qubits': [2, 3]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u5': {'operates': {'qubits': [3, 2]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u6': {'operates': {'qubits': [3, 4]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u7': {'operates': {'qubits': [4, 3]}, 'purpose': 'cross-resonance', 'type': 'control'}} |
| meas_kernels | ['boxcar'] |
| allow_q_object | True |
| dt | 2.2222222222222221e-10 |
| acquisition_latency | [] |
| url | None |
| rep_times | [0.001] |
| u_channel_lo | [[{'q': 1, 'scale': (1+0j)}], [{'q': 0, 'scale': (1+0j)}], [{'q': 2, 'scale': (1+0j)}], [{'q': 1, 'scale': (1+0j)}], [{'q': 3, 'scale': (1+0j)}], [{'q': 2, 'scale': (1+0j)}], [{'q': 4, 'scale': (1+0j)}], [{'q': 3, 'scale': (1+0j)}]] |
| n_registers | 1 |
| credits_required | True |
| dtm | 2.2222222222222221e-10 |
| qubit_channel_mapping | [['d0', 'm0', 'u0', 'u1'], ['m1', 'u1', 'u3', 'u2', 'u0', 'd1'], ['m2', 'u3', 'u2', 'u4', 'u5', 'd2'], ['m3', 'd3', 'u4', 'u5', 'u7', 'u6'], ['u7', 'd4', 'm4', 'u6']] |
| discriminators | ['quadratic_discriminator', 'linear_discriminator'] |
| dynamic_reprate_enabled | False |
| local | False |
| uchannels_enabled | True |
| memory | True |
| meas_lo_range | [[6952624018.0, 7952624018.0], [6701014434.0, 7701014434.0], [6837452605.0, 7837452605.0], [6901770712.0, 7901770712.0], [6775814414.0, 7775814414.0]] |
| simulator | False |
| conditional | False |
| online_date | 2020-06-03 04:00:00+00:00 |
| parametric_pulses | [] |
| description | 5 qubit device |
| meas_map | [[0, 1, 2, 3, 4]] |
| backend_name | ibmq_santiago |
| allow_object_storage | True |
| hamiltonian | $$\\begin{align} \\mathcal{H}/\\hbar = & \\sum_{i=0}^{4}\\left(\\frac{\\omega_{q,i}}{2}(\\mathbb{I}-\\sigma_i^{z})+\\frac{\\Delta_{i}}{2}(O_i^2-O_i)+\\Omega_{d,i}D_i(t)\\sigma_i^{X}\\right) \\\\ & + J_{0,1}(\\sigma_{0}^{+}\\sigma_{1}^{-}+\\sigma_{0}^{-}\\sigma_{1}^{+}) + J_{3,4}(\\sigma_{3}^{+}\\sigma_{4}^{-}+\\sigma_{3}^{-}\\sigma_{4}^{+}) + J_{2,3}(\\sigma_{2}^{+}\\sigma_{3}^{-}+\\sigma_{2}^{-}\\sigma_{3}^{+}) + J_{1,2}(\\sigma_{1}^{+}\\sigma_{2}^{-}+\\sigma_{1}^{-}\\sigma_{2}^{+}) \\\\ & + \\Omega_{d,0}(U_{0}^{(0,1)}(t))\\sigma_{0}^{X} + \\Omega_{d,1}(U_{1}^{(1,0)}(t)+U_{2}^{(1,2)}(t))\\sigma_{1}^{X} \\\\ & + \\Omega_{d,2}(U_{3}^{(2,1)}(t)+U_{4}^{(2,3)}(t))\\sigma_{2}^{X} + \\Omega_{d,3}(U_{6}^{(3,4)}(t)+U_{5}^{(3,2)}(t))\\sigma_{3}^{X} \\\\ & + \\Omega_{d,4}(U_{7}^{(4,3)}(t))\\sigma_{4}^{X} \\\\ \\end{align}$$ |
| meas_levels | [1, 2] |
| n_uchannels | 8 |
| Type | Gate error | |
|---|---|---|
| cx3_4 | cx | 0.00712 |
| cx4_3 | cx | 0.00712 |
| Type | Gate error | |
|---|---|---|
| cx2_1 | cx | 0.00697 |
| cx2_3 | cx | 0.00797 |
| cx3_2 | cx | 0.00797 |
| Type | Gate error | |
|---|---|---|
| cx0_1 | cx | 0.00677 |
| cx1_0 | cx | 0.00677 |
| cx1_2 | cx | 0.00697 |
| Frequency | T1 | T2 | U1 gate error | U2 gate error | U3 gate error | Readout error | |
|---|---|---|---|---|---|---|---|
| Q0 | 4.83343 GHz | 92.68711 µs | 157.17411 µs | 0 | 0.00022 | 0.00044 | 0.0125 |
| Q1 | 4.62385 GHz | 88.58389 µs | 94.28362 µs | 0 | 0.00016 | 0.00033 | 0.0205 |
| Q2 | 4.82053 GHz | 148.28351 µs | 93.83139 µs | 0 | 0.00025 | 0.00049 | 0.014 |
| Q3 | 4.74233 GHz | 183.80524 µs | 133.6838 µs | 0 | 0.00034 | 0.00067 | 0.0205 |
| Q4 | 4.81632 GHz | 139.69121 µs | 161.77685 µs | 0 | 0.00027 | 0.00055 | 0.0185 |
| Property | Value |
|---|---|
| n_qubits | 5 |
| quantum_volume | 32 |
| operational | True |
| status_msg | active |
| pending_jobs | 2 |
| backend_version | 1.0.0 |
| basis_gates | ['id', 'u1', 'u2', 'u3', 'cx'] |
| max_shots | 8192 |
| max_experiments | 75 |
| Type | Gate error | |
|---|---|---|
| cx3_4 | cx | 0.00712 |
| cx4_3 | cx | 0.00712 |
| dtm | 2.2222222222222221e-10 |
| meas_levels | [1, 2] |
| local | False |
| meas_kernels | ['boxcar'] |
| memory | True |
| simulator | False |
| hamiltonian | $$\\begin{align} \\mathcal{H}/\\hbar = & \\sum_{i=0}^{4}\\left(\\frac{\\omega_{q,i}}{2}(\\mathbb{I}-\\sigma_i^{z})+\\frac{\\Delta_{i}}{2}(O_i^2-O_i)+\\Omega_{d,i}D_i(t)\\sigma_i^{X}\\right) \\\\ & + J_{0,1}(\\sigma_{0}^{+}\\sigma_{1}^{-}+\\sigma_{0}^{-}\\sigma_{1}^{+}) + J_{3,4}(\\sigma_{3}^{+}\\sigma_{4}^{-}+\\sigma_{3}^{-}\\sigma_{4}^{+}) + J_{2,3}(\\sigma_{2}^{+}\\sigma_{3}^{-}+\\sigma_{2}^{-}\\sigma_{3}^{+}) + J_{1,2}(\\sigma_{1}^{+}\\sigma_{2}^{-}+\\sigma_{1}^{-}\\sigma_{2}^{+}) \\\\ & + \\Omega_{d,0}(U_{0}^{(0,1)}(t))\\sigma_{0}^{X} + \\Omega_{d,1}(U_{1}^{(1,0)}(t)+U_{2}^{(1,2)}(t))\\sigma_{1}^{X} \\\\ & + \\Omega_{d,2}(U_{3}^{(2,1)}(t)+U_{4}^{(2,3)}(t))\\sigma_{2}^{X} + \\Omega_{d,3}(U_{6}^{(3,4)}(t)+U_{5}^{(3,2)}(t))\\sigma_{3}^{X} \\\\ & + \\Omega_{d,4}(U_{7}^{(4,3)}(t))\\sigma_{4}^{X} \\\\ \\end{align}$$ |
| meas_map | [[0, 1, 2, 3, 4]] |
| parametric_pulses | [] |
| coupling_map | [[0, 1], [1, 0], [1, 2], [2, 1], [2, 3], [3, 2], [3, 4], [4, 3]] |
| url | None |
| open_pulse | False |
| u_channel_lo | [[{'q': 1, 'scale': (1+0j)}], [{'q': 0, 'scale': (1+0j)}], [{'q': 2, 'scale': (1+0j)}], [{'q': 1, 'scale': (1+0j)}], [{'q': 3, 'scale': (1+0j)}], [{'q': 2, 'scale': (1+0j)}], [{'q': 4, 'scale': (1+0j)}], [{'q': 3, 'scale': (1+0j)}]] |
| dynamic_reprate_enabled | False |
| uchannels_enabled | True |
| allow_object_storage | True |
| meas_lo_range | [[6952624018.0, 7952624018.0], [6701014434.0, 7701014434.0], [6837452605.0, 7837452605.0], [6901770712.0, 7901770712.0], [6775814414.0, 7775814414.0]] |
| allow_q_object | True |
| credits_required | True |
| discriminators | ['quadratic_discriminator', 'linear_discriminator'] |
| sample_name | Snake |
| qubit_lo_range | [[4333430597.562168, 5333430597.562168], [4123852322.963768, 5123852322.963768], [4320531275.264617, 5320531275.264617], [4242331971.9375987, 5242331971.937599], [4316318056.924669, 5316318056.924669]] |
| qubit_channel_mapping | [['d0', 'm0', 'u0', 'u1'], ['m1', 'u1', 'u3', 'u2', 'u0', 'd1'], ['m2', 'u3', 'u2', 'u4', 'u5', 'd2'], ['m3', 'd3', 'u4', 'u5', 'u7', 'u6'], ['u7', 'd4', 'm4', 'u6']] |
| description | 5 qubit device |
| conditional_latency | [] |
| backend_name | ibmq_santiago |
| dt | 2.2222222222222221e-10 |
| rep_times | [0.001] |
| online_date | 2020-06-03 04:00:00+00:00 |
| conditional | False |
| n_uchannels | 8 |
| n_registers | 1 |
| acquisition_latency | [] |
| channels | {'acquire0': {'operates': {'qubits': [0]}, 'purpose': 'acquire', 'type': 'acquire'}, 'acquire1': {'operates': {'qubits': [1]}, 'purpose': 'acquire', 'type': 'acquire'}, 'acquire2': {'operates': {'qubits': [2]}, 'purpose': 'acquire', 'type': 'acquire'}, 'acquire3': {'operates': {'qubits': [3]}, 'purpose': 'acquire', 'type': 'acquire'}, 'acquire4': {'operates': {'qubits': [4]}, 'purpose': 'acquire', 'type': 'acquire'}, 'd0': {'operates': {'qubits': [0]}, 'purpose': 'drive', 'type': 'drive'}, 'd1': {'operates': {'qubits': [1]}, 'purpose': 'drive', 'type': 'drive'}, 'd2': {'operates': {'qubits': [2]}, 'purpose': 'drive', 'type': 'drive'}, 'd3': {'operates': {'qubits': [3]}, 'purpose': 'drive', 'type': 'drive'}, 'd4': {'operates': {'qubits': [4]}, 'purpose': 'drive', 'type': 'drive'}, 'm0': {'operates': {'qubits': [0]}, 'purpose': 'measure', 'type': 'measure'}, 'm1': {'operates': {'qubits': [1]}, 'purpose': 'measure', 'type': 'measure'}, 'm2': {'operates': {'qubits': [2]}, 'purpose': 'measure', 'type': 'measure'}, 'm3': {'operates': {'qubits': [3]}, 'purpose': 'measure', 'type': 'measure'}, 'm4': {'operates': {'qubits': [4]}, 'purpose': 'measure', 'type': 'measure'}, 'u0': {'operates': {'qubits': [0, 1]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u1': {'operates': {'qubits': [1, 0]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u2': {'operates': {'qubits': [1, 2]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u3': {'operates': {'qubits': [2, 1]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u4': {'operates': {'qubits': [2, 3]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u5': {'operates': {'qubits': [3, 2]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u6': {'operates': {'qubits': [3, 4]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u7': {'operates': {'qubits': [4, 3]}, 'purpose': 'cross-resonance', 'type': 'control'}} |
| Property | Value |
|---|---|
| n_qubits | 5 |
| quantum_volume | 32 |
| operational | True |
| status_msg | active |
| pending_jobs | 0 |
| backend_version | 1.0.0 |
| basis_gates | ['id', 'u1', 'u2', 'u3', 'cx'] |
| max_shots | 8192 |
| max_experiments | 75 |
| Frequency | T1 | T2 | U1 gate error | U2 gate error | U3 gate error | Readout error | |
|---|---|---|---|---|---|---|---|
| Q0 | 4.83343 GHz | 92.68711 µs | 157.17411 µs | 0 | 0.00022 | 0.00044 | 0.0125 |
| Q1 | 4.62385 GHz | 88.58389 µs | 94.28362 µs | 0 | 0.00016 | 0.00033 | 0.0205 |
| Q2 | 4.82053 GHz | 148.28351 µs | 93.83139 µs | 0 | 0.00025 | 0.00049 | 0.014 |
| Q3 | 4.74233 GHz | 183.80524 µs | 133.6838 µs | 0 | 0.00034 | 0.00067 | 0.0205 |
| Q4 | 4.81632 GHz | 139.69121 µs | 161.77685 µs | 0 | 0.00027 | 0.00055 | 0.0185 |
| Type | Gate error | |
|---|---|---|
| cx0_1 | cx | 0.00677 |
| cx1_0 | cx | 0.00677 |
| cx1_2 | cx | 0.00697 |
| dtm | 2.2222222222222221e-10 |
| meas_levels | [1, 2] |
| local | False |
| meas_kernels | ['boxcar'] |
| memory | True |
| simulator | False |
| hamiltonian | $$\\begin{align} \\mathcal{H}/\\hbar = & \\sum_{i=0}^{4}\\left(\\frac{\\omega_{q,i}}{2}(\\mathbb{I}-\\sigma_i^{z})+\\frac{\\Delta_{i}}{2}(O_i^2-O_i)+\\Omega_{d,i}D_i(t)\\sigma_i^{X}\\right) \\\\ & + J_{0,1}(\\sigma_{0}^{+}\\sigma_{1}^{-}+\\sigma_{0}^{-}\\sigma_{1}^{+}) + J_{3,4}(\\sigma_{3}^{+}\\sigma_{4}^{-}+\\sigma_{3}^{-}\\sigma_{4}^{+}) + J_{2,3}(\\sigma_{2}^{+}\\sigma_{3}^{-}+\\sigma_{2}^{-}\\sigma_{3}^{+}) + J_{1,2}(\\sigma_{1}^{+}\\sigma_{2}^{-}+\\sigma_{1}^{-}\\sigma_{2}^{+}) \\\\ & + \\Omega_{d,0}(U_{0}^{(0,1)}(t))\\sigma_{0}^{X} + \\Omega_{d,1}(U_{1}^{(1,0)}(t)+U_{2}^{(1,2)}(t))\\sigma_{1}^{X} \\\\ & + \\Omega_{d,2}(U_{3}^{(2,1)}(t)+U_{4}^{(2,3)}(t))\\sigma_{2}^{X} + \\Omega_{d,3}(U_{6}^{(3,4)}(t)+U_{5}^{(3,2)}(t))\\sigma_{3}^{X} \\\\ & + \\Omega_{d,4}(U_{7}^{(4,3)}(t))\\sigma_{4}^{X} \\\\ \\end{align}$$ |
| meas_map | [[0, 1, 2, 3, 4]] |
| parametric_pulses | [] |
| coupling_map | [[0, 1], [1, 0], [1, 2], [2, 1], [2, 3], [3, 2], [3, 4], [4, 3]] |
| url | None |
| open_pulse | False |
| u_channel_lo | [[{'q': 1, 'scale': (1+0j)}], [{'q': 0, 'scale': (1+0j)}], [{'q': 2, 'scale': (1+0j)}], [{'q': 1, 'scale': (1+0j)}], [{'q': 3, 'scale': (1+0j)}], [{'q': 2, 'scale': (1+0j)}], [{'q': 4, 'scale': (1+0j)}], [{'q': 3, 'scale': (1+0j)}]] |
| dynamic_reprate_enabled | False |
| uchannels_enabled | True |
| allow_object_storage | True |
| meas_lo_range | [[6952624018.0, 7952624018.0], [6701014434.0, 7701014434.0], [6837452605.0, 7837452605.0], [6901770712.0, 7901770712.0], [6775814414.0, 7775814414.0]] |
| allow_q_object | True |
| credits_required | True |
| discriminators | ['quadratic_discriminator', 'linear_discriminator'] |
| sample_name | Snake |
| qubit_lo_range | [[4333430597.562168, 5333430597.562168], [4123852322.963768, 5123852322.963768], [4320531275.264617, 5320531275.264617], [4242331971.9375987, 5242331971.937599], [4316318056.924669, 5316318056.924669]] |
| qubit_channel_mapping | [['d0', 'm0', 'u0', 'u1'], ['m1', 'u1', 'u3', 'u2', 'u0', 'd1'], ['m2', 'u3', 'u2', 'u4', 'u5', 'd2'], ['m3', 'd3', 'u4', 'u5', 'u7', 'u6'], ['u7', 'd4', 'm4', 'u6']] |
| description | 5 qubit device |
| conditional_latency | [] |
| backend_name | ibmq_santiago |
| dt | 2.2222222222222221e-10 |
| rep_times | [0.001] |
| online_date | 2020-06-03 04:00:00+00:00 |
| conditional | False |
| n_uchannels | 8 |
| n_registers | 1 |
| acquisition_latency | [] |
| channels | {'acquire0': {'operates': {'qubits': [0]}, 'purpose': 'acquire', 'type': 'acquire'}, 'acquire1': {'operates': {'qubits': [1]}, 'purpose': 'acquire', 'type': 'acquire'}, 'acquire2': {'operates': {'qubits': [2]}, 'purpose': 'acquire', 'type': 'acquire'}, 'acquire3': {'operates': {'qubits': [3]}, 'purpose': 'acquire', 'type': 'acquire'}, 'acquire4': {'operates': {'qubits': [4]}, 'purpose': 'acquire', 'type': 'acquire'}, 'd0': {'operates': {'qubits': [0]}, 'purpose': 'drive', 'type': 'drive'}, 'd1': {'operates': {'qubits': [1]}, 'purpose': 'drive', 'type': 'drive'}, 'd2': {'operates': {'qubits': [2]}, 'purpose': 'drive', 'type': 'drive'}, 'd3': {'operates': {'qubits': [3]}, 'purpose': 'drive', 'type': 'drive'}, 'd4': {'operates': {'qubits': [4]}, 'purpose': 'drive', 'type': 'drive'}, 'm0': {'operates': {'qubits': [0]}, 'purpose': 'measure', 'type': 'measure'}, 'm1': {'operates': {'qubits': [1]}, 'purpose': 'measure', 'type': 'measure'}, 'm2': {'operates': {'qubits': [2]}, 'purpose': 'measure', 'type': 'measure'}, 'm3': {'operates': {'qubits': [3]}, 'purpose': 'measure', 'type': 'measure'}, 'm4': {'operates': {'qubits': [4]}, 'purpose': 'measure', 'type': 'measure'}, 'u0': {'operates': {'qubits': [0, 1]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u1': {'operates': {'qubits': [1, 0]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u2': {'operates': {'qubits': [1, 2]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u3': {'operates': {'qubits': [2, 1]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u4': {'operates': {'qubits': [2, 3]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u5': {'operates': {'qubits': [3, 2]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u6': {'operates': {'qubits': [3, 4]}, 'purpose': 'cross-resonance', 'type': 'control'}, 'u7': {'operates': {'qubits': [4, 3]}, 'purpose': 'cross-resonance', 'type': 'control'}} |
| Type | Gate error | |
|---|---|---|
| cx3_4 | cx | 0.00712 |
| cx4_3 | cx | 0.00712 |
Circuit Properties
" + } + }, + "ad3dbc4974774b2fa7114c602987ed4b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "ade0a1cf0b3a46baaedc39f025ffdbb0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_gap": "0px 0px", + "grid_template_areas": "\n \"left right right right\"\n \"bottom bottom bottom bottom\"\n ", + "grid_template_columns": "31% 23% 23% 23%", + "grid_template_rows": "auto auto" + } + }, + "afc56bc4612b4c3eaea4a9fe4ace6dce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_area": "right" + } + }, + "b1f204f1502640f28b817d4178016b9b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "b348f8e7cdc54c89aa1fc1a70e0ab518": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "TabModel", + "state": { + "_titles": { + "0": "Configuration", + "1": "Qubit Properties", + "2": "Multi-Qubit Gates", + "3": "Error Map", + "4": "Job History" + }, + "children": [ + "IPY_MODEL_b53ff551702347eba6a46ddc4cb7f2fe", + "IPY_MODEL_396d5eea41404a1fb3bf190bcc821bc5", + "IPY_MODEL_92a5dca6784046a18e81e10d61afa119", + "IPY_MODEL_f7f4cfc0d755411f89a0bdce5dcad88e", + "IPY_MODEL_09c2053b68af4162b72b94bbd39e2d10" + ], + "layout": "IPY_MODEL_d498823102984e0081af43104c967ca4" + } + }, + "b53ff551702347eba6a46ddc4cb7f2fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "GridBoxModel", + "state": { + "children": [ + "IPY_MODEL_71fea12ba96e44168cd4fae223e18325", + "IPY_MODEL_6211098838b44d6f83f01301b6bcc823", + "IPY_MODEL_882164748d60474caf727353d875cc24" + ], + "layout": "IPY_MODEL_4a245758633a4388a0ce5a5ff5bd594e" + } + }, + "b5865e92f36b4f5e8bac678873837a50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "b5a308681d1b4c27a2909817fa86947c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "b5fad6f29174493d874966f16229b04f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "190px" + } + }, + "b7b54ed14be149b4a97c353f453d1ff2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "bbae36f498ff4143b10a780c0d160201": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_area": "right" + } + }, + "bdd500a138c349dba647397770c3afac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_area": "middle" + } + }, + "be167568476440688a87221c8e63add6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "align_items": "center", + "display": "flex-inline", + "grid_area": "right", + "max_height": "325px", + "padding": "10px 10px 10px 10px", + "width": "auto" + } + }, + "be552461accd4f76a6d642205f2b89f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_94d6d3c309b0477bb1d66e1716df43ab", + "style": "IPY_MODEL_a56b194594ef49c88f63173ae26d6819", + "value": "| Property | Value |
|---|---|
| n_qubits | 5 |
| quantum_volume | 32 |
| operational | True |
| status_msg | active |
| pending_jobs | 3 |
| backend_version | 1.0.0 |
| basis_gates | ['id', 'u1', 'u2', 'u3', 'cx'] |
| max_shots | 8192 |
| max_experiments | 75 |
| Frequency | T1 | T2 | U1 gate error | U2 gate error | U3 gate error | Readout error | |
|---|---|---|---|---|---|---|---|
| Q0 | 4.83343 GHz | 92.68711 µs | 157.17411 µs | 0 | 0.00022 | 0.00044 | 0.0125 |
| Q1 | 4.62385 GHz | 88.58389 µs | 94.28362 µs | 0 | 0.00016 | 0.00033 | 0.0205 |
| Q2 | 4.82053 GHz | 148.28351 µs | 93.83139 µs | 0 | 0.00025 | 0.00049 | 0.014 |
| Q3 | 4.74233 GHz | 183.80524 µs | 133.6838 µs | 0 | 0.00034 | 0.00067 | 0.0205 |
| Q4 | 4.81632 GHz | 139.69121 µs | 161.77685 µs | 0 | 0.00027 | 0.00055 | 0.0185 |
| Type | Gate error | |
|---|---|---|
| cx2_1 | cx | 0.00697 |
| cx2_3 | cx | 0.00797 |
| cx3_2 | cx | 0.00797 |
| Type | Gate error | |
|---|---|---|
| cx0_1 | cx | 0.00677 |
| cx1_0 | cx | 0.00677 |
| cx1_2 | cx | 0.00697 |
Circuit Properties
" + } + }, + "ffa650e4fccf4d36b4aa8bbc72378b4e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_area": "left" + } + } + }, + "version_major": 2, + "version_minor": 0 + } } }, "nbformat": 4, From 66269afe9d2ee1c1647fa6f287821c5f7e9613eb Mon Sep 17 00:00:00 2001 From: duarte-jfs <60704674+duarte-jfs@users.noreply.github.com> Date: Wed, 12 Aug 2020 16:56:15 +0100 Subject: [PATCH 2/2] Better visuals on github --- .../Ising_time_evolution.ipynb | 110 +++--------------- 1 file changed, 14 insertions(+), 96 deletions(-) diff --git a/awards/teach_me_qiskit_2018/exact_ising_model_simulation/Ising_time_evolution.ipynb b/awards/teach_me_qiskit_2018/exact_ising_model_simulation/Ising_time_evolution.ipynb index c3089c6..1f3d68e 100644 --- a/awards/teach_me_qiskit_2018/exact_ising_model_simulation/Ising_time_evolution.ipynb +++ b/awards/teach_me_qiskit_2018/exact_ising_model_simulation/Ising_time_evolution.ipynb @@ -93,34 +93,13 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 165, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "In C:\\Users\\duart\\Anaconda3\\envs\\qiskit_env\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: \n", - "The text.latex.preview rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In C:\\Users\\duart\\Anaconda3\\envs\\qiskit_env\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: \n", - "The mathtext.fallback_to_cm rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In C:\\Users\\duart\\Anaconda3\\envs\\qiskit_env\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: Support for setting the 'mathtext.fallback_to_cm' rcParam is deprecated since 3.3 and will be removed two minor releases later; use 'mathtext.fallback : 'cm' instead.\n", - "In C:\\Users\\duart\\Anaconda3\\envs\\qiskit_env\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: \n", - "The validate_bool_maybe_none function was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In C:\\Users\\duart\\Anaconda3\\envs\\qiskit_env\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: \n", - "The savefig.jpeg_quality rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In C:\\Users\\duart\\Anaconda3\\envs\\qiskit_env\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: \n", - "The keymap.all_axes rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In C:\\Users\\duart\\Anaconda3\\envs\\qiskit_env\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: \n", - "The animation.avconv_path rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In C:\\Users\\duart\\Anaconda3\\envs\\qiskit_env\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test.mplstyle: \n", - "The animation.avconv_args rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n" - ] - }, { "data": { "text/html": [ - "| Qiskit Software | Version |
|---|---|
| Qiskit | 0.19.6 |
| Terra | 0.14.2 |
| Aer | 0.5.2 |
| Ignis | 0.3.3 |
| Aqua | 0.7.3 |
| IBM Q Provider | 0.7.2 |
| System information | |
| Python | 3.7.6 (default, Jan 8 2020, 20:23:39) [MSC v.1916 64 bit (AMD64)] |
| OS | Windows |
| CPUs | 2 |
| Memory (Gb) | 7.886066436767578 |
| Wed Aug 12 14:54:09 2020 Hora de Verão de GMT | |
| Qiskit Software | Version |
|---|---|
| Qiskit | 0.19.6 |
| Terra | 0.14.2 |
| Aer | 0.5.2 |
| Ignis | 0.3.3 |
| Aqua | 0.7.3 |
| IBM Q Provider | 0.7.2 |
| System information | |
| Python | 3.7.6 (default, Jan 8 2020, 20:23:39) [MSC v.1916 64 bit (AMD64)] |
| OS | Windows |
| CPUs | 2 |
| Memory (Gb) | 7.886066436767578 |
| Wed Aug 12 16:55:27 2020 Hora de Verão de GMT | |
┌───┐ ┌───┐ ┌───┐ ┌───┐┌───┐┌───┐┌───┐┌───────────┐ ┌───┐ ┌───┐┌───┐┌───┐┌───┐ ┌─┐ \n", - "q_0: |0>───────────────┤ X ├────────────────────────────────────■────────────────────────■──────────────┤ X ├─────┤ X ├─────────────────────■─────────────────┤ X ├┤ H ├┤ X ├┤ H ├┤ U1(-pi/2) ├───────────────┤ X ├────────────────────────■──────────────────┤ X ├┤ H ├┤ X ├┤ H ├─────┤M├────────────────────────────────────\n", - " ┌───┐ └─┬─┘┌───────────┐┌──────────────────┐ ┌─┴─┐ ┌─────────────────┐┌─┴─┐┌──────────┐└─┬─┘┌───┐└─┬─┘┌─────┐┌───┐┌─────┐┌─┴─┐┌───┐┌───┐┌───┐└─┬─┘└───┘└─┬─┘└───┘└───┬───┬───┘ └─┬─┘┌─────┐ ┌───┐ ┌─────┐ ┌─┴─┐ ┌───┐┌───┐┌───┐└─┬─┘└───┘└─┬─┘└───┘ └╥┘ ┌───┐ ┌─┐ \n", - "q_1: |0>─────┤ X ├───────■──┤ U1(-pi/2) ├┤ U3(-0.66291,0,0) ├─┤ X ├─┤ U3(0.66291,0,0) ├┤ X ├┤ U1(pi/2) ├──■──┤ X ├──■──┤ SDG ├┤ H ├┤ TDG ├┤ X ├┤ T ├┤ H ├┤ S ├──■─────────■────■──────┤ X ├──────■─────────■────■──┤ SDG ├─┤ H ├─┤ TDG ├─┤ X ├─┤ T ├┤ H ├┤ S ├──■─────────■─────────────╫───■──┤ X ├──■─────────■───────┤M├───\n", - " └───┘ ┌───┐└───────────┘└──────────────────┘ └───┘ └─────────────────┘└───┘└──────────┘ ├───┤┌───┐└┬───┬┘├───┤└─────┘└───┘└───┘└───┘└───┘ ┌─┴─┐ └─┬─┘ ┌─┴─┐┌───┐┌─┴─┐┌───┐└┬───┬┘ └───┘ └─────┘ └───┘ └───┘└───┘└───┘ ┌───┐┌───┐┌───┐┌───┐ ║ ┌─┴─┐└─┬─┘┌─┴─┐┌───┐┌─┴─┐┌───┐└╥┘┌─┐\n", - "q_2: |0>───────────────┤ X ├─────────────────────────────────────────────────■───────────────────────────────┤ X ├┤ H ├─┤ X ├─┤ H ├──────────────────────────────────────────┤ X ├──────■──────┤ X ├┤ H ├┤ X ├┤ H ├─┤ X ├────────────────────────■─────────────────┤ X ├┤ H ├┤ X ├┤ H ├─╫─┤ X ├──■──┤ X ├┤ H ├┤ X ├┤ H ├─╫─┤M├\n", - " ┌─────────────┐└─┬─┘ ┌─────┐ ┌───┐ ┌─────┐ ┌─┴─┐ ┌───┐ ┌───┐ ┌───┐└─┬─┘└───┘ └─┬─┘ └───┘ └───┘ └───┘└───┘└───┘└───┘ └─┬─┘ ┌─────┐ ┌───┐ ┌─────┐┌─┴─┐┌───┐┌───┐┌───┐└─┬─┘└───┘└─┬─┘└┬─┬┘ ║ └───┘ └───┘└───┘└───┘└───┘ ║ └╥┘\n", - "q_3: |0>┤ U3(pi,0,pi) ├──■─────┤ SDG ├──────────┤ H ├────────┤ TDG ├───────┤ X ├───────┤ T ├───┤ H ├────┤ S ├──■──────────■───────────────────────────────────────────────────────────────────────────────────────────■───┤ SDG ├─┤ H ├─┤ TDG ├┤ X ├┤ T ├┤ H ├┤ S ├──■─────────■───┤M├──╫────────────────────────────────╫──╫─\n", - " └─────────────┘ └─────┘ └───┘ └─────┘ └───┘ └───┘ └───┘ └───┘ └─────┘ └───┘ └─────┘└───┘└───┘└───┘└───┘ └╥┘ ║ ║ ║ \n", - " c: 0 4/════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╩═══╩════════════════════════════════╩══╩═\n", - " 3 0 1 2" - ], + "image/png": "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\n", "text/plain": [ - " ┌───┐ ┌───┐ ┌───┐ ┌───┐┌───┐┌───┐┌───┐┌───────────┐ ┌───┐ ┌───┐┌───┐┌───┐┌───┐ ┌─┐ \n", - "q_0: |0>───────────────┤ X ├────────────────────────────────────■────────────────────────■──────────────┤ X ├─────┤ X ├─────────────────────■─────────────────┤ X ├┤ H ├┤ X ├┤ H ├┤ U1(-pi/2) ├───────────────┤ X ├────────────────────────■──────────────────┤ X ├┤ H ├┤ X ├┤ H ├─────┤M├────────────────────────────────────\n", - " ┌───┐ └─┬─┘┌───────────┐┌──────────────────┐ ┌─┴─┐ ┌─────────────────┐┌─┴─┐┌──────────┐└─┬─┘┌───┐└─┬─┘┌─────┐┌───┐┌─────┐┌─┴─┐┌───┐┌───┐┌───┐└─┬─┘└───┘└─┬─┘└───┘└───┬───┬───┘ └─┬─┘┌─────┐ ┌───┐ ┌─────┐ ┌─┴─┐ ┌───┐┌───┐┌───┐└─┬─┘└───┘└─┬─┘└───┘ └╥┘ ┌───┐ ┌─┐ \n", - "q_1: |0>─────┤ X ├───────■──┤ U1(-pi/2) ├┤ U3(-0.66291,0,0) ├─┤ X ├─┤ U3(0.66291,0,0) ├┤ X ├┤ U1(pi/2) ├──■──┤ X ├──■──┤ SDG ├┤ H ├┤ TDG ├┤ X ├┤ T ├┤ H ├┤ S ├──■─────────■────■──────┤ X ├──────■─────────■────■──┤ SDG ├─┤ H ├─┤ TDG ├─┤ X ├─┤ T ├┤ H ├┤ S ├──■─────────■─────────────╫───■──┤ X ├──■─────────■───────┤M├───\n", - " └───┘ ┌───┐└───────────┘└──────────────────┘ └───┘ └─────────────────┘└───┘└──────────┘ ├───┤┌───┐└┬───┬┘├───┤└─────┘└───┘└───┘└───┘└───┘ ┌─┴─┐ └─┬─┘ ┌─┴─┐┌───┐┌─┴─┐┌───┐└┬───┬┘ └───┘ └─────┘ └───┘ └───┘└───┘└───┘ ┌───┐┌───┐┌───┐┌───┐ ║ ┌─┴─┐└─┬─┘┌─┴─┐┌───┐┌─┴─┐┌───┐└╥┘┌─┐\n", - "q_2: |0>───────────────┤ X ├─────────────────────────────────────────────────■───────────────────────────────┤ X ├┤ H ├─┤ X ├─┤ H ├──────────────────────────────────────────┤ X ├──────■──────┤ X ├┤ H ├┤ X ├┤ H ├─┤ X ├────────────────────────■─────────────────┤ X ├┤ H ├┤ X ├┤ H ├─╫─┤ X ├──■──┤ X ├┤ H ├┤ X ├┤ H ├─╫─┤M├\n", - " ┌─────────────┐└─┬─┘ ┌─────┐ ┌───┐ ┌─────┐ ┌─┴─┐ ┌───┐ ┌───┐ ┌───┐└─┬─┘└───┘ └─┬─┘ └───┘ └───┘ └───┘└───┘└───┘└───┘ └─┬─┘ ┌─────┐ ┌───┐ ┌─────┐┌─┴─┐┌───┐┌───┐┌───┐└─┬─┘└───┘└─┬─┘└┬─┬┘ ║ └───┘ └───┘└───┘└───┘└───┘ ║ └╥┘\n", - "q_3: |0>┤ U3(pi,0,pi) ├──■─────┤ SDG ├──────────┤ H ├────────┤ TDG ├───────┤ X ├───────┤ T ├───┤ H ├────┤ S ├──■──────────■───────────────────────────────────────────────────────────────────────────────────────────■───┤ SDG ├─┤ H ├─┤ TDG ├┤ X ├┤ T ├┤ H ├┤ S ├──■─────────■───┤M├──╫────────────────────────────────╫──╫─\n", - " └─────────────┘ └─────┘ └───┘ └─────┘ └───┘ └───┘ └───┘ └───┘ └─────┘ └───┘ └─────┘└───┘└───┘└───┘└───┘ └╥┘ ║ ║ ║ \n", - " c: 0 4/════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╩═══╩════════════════════════════════╩══╩═\n", - " 3 0 1 2 " + "
┌──────────────────────┐ ┌────────────────────┐ ┌───────────┐ ┌───────────────────┐ ┌──────────────┐ ┌─┐ \n", - " q_0 -> 0 |0>┤ U3(pi/2,3pi/2,-pi/4) ├──■──┤ U3(3.0191,0,3pi/2) ├──■────────┤ U1(3pi/2) ├───────────────────────────────────────────────────────■──┤ U3(3pi/4,0,3pi/2) ├──■──────┤ U2(3pi/4,pi) ├────────┤M├──────────────────────────────────────\n", - " └──┬────────────────┬──┘┌─┴─┐├───────────────────┬┘┌─┴─┐┌─────┴───────────┴─────┐ ┌─────────────┐ ┌────────────────────┐┌─┴─┐└─┬────────────────┬┘┌─┴─┐ ┌──┴──────────────┴─┐ └╥┘┌─────────────┐ ┌─────────────┐┌─┐\n", - " q_1 -> 1 |0>───┤ U2(pi/2,5pi/4) ├───┤ X ├┤ U2(3pi/2,0.12249) ├─┤ X ├┤ U3(pi/2,3pi/2,2.1196) ├──■──┤ U2(0,3pi/2) ├──■──┤ U3(2.1196,pi,pi/2) ├┤ X ├──┤ U2(3pi/2,pi/4) ├─┤ X ├─┤ U2(3pi/2,0.54878) ├───■───╫─┤ U2(0,3pi/2) ├──■──┤ U2(4.949,0) ├┤M├\n", - " ┌─┴────────────────┴┐ └───┘├───────────────────┤ └───┘└┬─────────────────────┬┘┌─┴─┐├─────────────┤┌─┴─┐├───────────────────┬┘└───┘┌─┴────────────────┴┐└───┘┌┴───────────────────┴┐┌─┴─┐ ║ ├─────────────┤┌─┴─┐└─────┬─┬─────┘└╥┘\n", - " q_2 -> 2 |0>─┤ U2(pi/2,-0.66453) ├────■──┤ U3(3pi/4,0,3pi/2) ├───■───┤ U3(2.7137,2pi,pi/2) ├─┤ X ├┤ U2(3pi/2,0) ├┤ X ├┤ U2(-pi/2,-2.5928) ├───■──┤ U3(3pi/4,0,3pi/2) ├──■──┤ U3(1.022,2pi,3pi/2) ├┤ X ├─╫─┤ U2(3pi/2,0) ├┤ X ├──────┤M├───────╫─\n", - " └┬──────────────────┤ ┌─┴─┐└─┬────────────────┬┘ ┌─┴─┐ └─┬──────────────────┬┘ └───┘└─────────────┘└───┘└───────────────────┘ ┌─┴─┐└─┬────────────────┬┘┌─┴─┐├─────────────────────┤└┬─┬┘ ║ └─────────────┘└───┘ └╥┘ ║ \n", - " q_3 -> 3 |0>──┤ U2(pi/2,-4.0479) ├──┤ X ├──┤ U2(3pi/2,pi/4) ├──┤ X ├───┤ U2(pi/2,-3.2625) ├─────────────────────────────────────────────────┤ X ├──┤ U2(3pi/2,pi/4) ├─┤ X ├┤ U3(pi,-3pi/2,-pi/4) ├─┤M├──╫────────────────────────────╫────────╫─\n", - " └──────────────────┘ └───┘ └────────────────┘ └───┘ └──────────────────┘ └───┘ └────────────────┘ └───┘└─────────────────────┘ └╥┘ ║ ║ ║ \n", - "ancilla_0 -> 4 |0>────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╫───╫────────────────────────────╫────────╫─\n", - " ║ ║ ║ ║ \n", - " c: 0 4/════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╩═══╩════════════════════════════╩════════╩═\n", - " 3 0 2 1" - ], + "image/png": "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\n", "text/plain": [ - " ┌──────────────────────┐ ┌────────────────────┐ ┌───────────┐ ┌───────────────────┐ ┌──────────────┐ ┌─┐ \n", - " q_0 -> 0 |0>┤ U3(pi/2,3pi/2,-pi/4) ├──■──┤ U3(3.0191,0,3pi/2) ├──■────────┤ U1(3pi/2) ├───────────────────────────────────────────────────────■──┤ U3(3pi/4,0,3pi/2) ├──■──────┤ U2(3pi/4,pi) ├────────┤M├──────────────────────────────────────\n", - " └──┬────────────────┬──┘┌─┴─┐├───────────────────┬┘┌─┴─┐┌─────┴───────────┴─────┐ ┌─────────────┐ ┌────────────────────┐┌─┴─┐└─┬────────────────┬┘┌─┴─┐ ┌──┴──────────────┴─┐ └╥┘┌─────────────┐ ┌─────────────┐┌─┐\n", - " q_1 -> 1 |0>───┤ U2(pi/2,5pi/4) ├───┤ X ├┤ U2(3pi/2,0.12249) ├─┤ X ├┤ U3(pi/2,3pi/2,2.1196) ├──■──┤ U2(0,3pi/2) ├──■──┤ U3(2.1196,pi,pi/2) ├┤ X ├──┤ U2(3pi/2,pi/4) ├─┤ X ├─┤ U2(3pi/2,0.54878) ├───■───╫─┤ U2(0,3pi/2) ├──■──┤ U2(4.949,0) ├┤M├\n", - " ┌─┴────────────────┴┐ └───┘├───────────────────┤ └───┘└┬─────────────────────┬┘┌─┴─┐├─────────────┤┌─┴─┐├───────────────────┬┘└───┘┌─┴────────────────┴┐└───┘┌┴───────────────────┴┐┌─┴─┐ ║ ├─────────────┤┌─┴─┐└─────┬─┬─────┘└╥┘\n", - " q_2 -> 2 |0>─┤ U2(pi/2,-0.66453) ├────■──┤ U3(3pi/4,0,3pi/2) ├───■───┤ U3(2.7137,2pi,pi/2) ├─┤ X ├┤ U2(3pi/2,0) ├┤ X ├┤ U2(-pi/2,-2.5928) ├───■──┤ U3(3pi/4,0,3pi/2) ├──■──┤ U3(1.022,2pi,3pi/2) ├┤ X ├─╫─┤ U2(3pi/2,0) ├┤ X ├──────┤M├───────╫─\n", - " └┬──────────────────┤ ┌─┴─┐└─┬────────────────┬┘ ┌─┴─┐ └─┬──────────────────┬┘ └───┘└─────────────┘└───┘└───────────────────┘ ┌─┴─┐└─┬────────────────┬┘┌─┴─┐├─────────────────────┤└┬─┬┘ ║ └─────────────┘└───┘ └╥┘ ║ \n", - " q_3 -> 3 |0>──┤ U2(pi/2,-4.0479) ├──┤ X ├──┤ U2(3pi/2,pi/4) ├──┤ X ├───┤ U2(pi/2,-3.2625) ├─────────────────────────────────────────────────┤ X ├──┤ U2(3pi/2,pi/4) ├─┤ X ├┤ U3(pi,-3pi/2,-pi/4) ├─┤M├──╫────────────────────────────╫────────╫─\n", - " └──────────────────┘ └───┘ └────────────────┘ └───┘ └──────────────────┘ └───┘ └────────────────┘ └───┘└─────────────────────┘ └╥┘ ║ ║ ║ \n", - "ancilla_0 -> 4 |0>────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╫───╫────────────────────────────╫────────╫─\n", - " ║ ║ ║ ║ \n", - " c: 0 4/════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╩═══╩════════════════════════════╩════════╩═\n", - " 3 0 2 1 " + "