qiskit/terra/quantum_circuits.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../../images/qiskit-heading.gif\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" width=\"500 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantum Circuits\n",
    "\n",
    "The `QuantumCircuit`, `QuantumRegister`, and `ClassicalRegister` are the main objects for Qiskit Terra. Most users will be able to do all they want with these objects. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister\n",
    "from qiskit import BasicAer, execute\n",
    "from qiskit.quantum_info import Pauli, state_fidelity, basis_state, process_fidelity "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum and Classical Registers\n",
    "\n",
    "Quantum and Classical Registers are declared using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "q0 = QuantumRegister(2, 'q0')\n",
    "c0 = ClassicalRegister(2, 'c0')\n",
    "q1 = QuantumRegister(2, 'q1')\n",
    "c1 = ClassicalRegister(2, 'c1')\n",
    "q_test = QuantumRegister(2, 'q0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The name is optional. If not given Qiskit will name it $qi$ where $i$ is an interger which will count from 0. The name and size can be returned using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "q0\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(q0.name)\n",
    "print(q0.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can test if the register are the same or different. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q0==q0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q0==q_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q0==q1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum Circuits\n",
    "\n",
    "Quantum Circuits are made using registers. Either when initiated or by using the `add_register` command. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;line-height: 15px;\">                   \n",
       "q0_0: |0>──────────\n",
       "              ┌───┐\n",
       "q0_1: |0>─────┤ X ├\n",
       "         ┌───┐└───┘\n",
       "q1_0: |0>┤ X ├─────\n",
       "         └───┘     \n",
       "q1_1: |0>──────────\n",
       "                   </pre>"
      ],
      "text/plain": [
       "<qiskit.tools.visualization._text.TextDrawing at 0xa209262b0>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circ = QuantumCircuit(q0, q1)\n",
    "circ.x(q0[1])\n",
    "circ.x(q1[0])\n",
    "circ.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "is the same as "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;line-height: 15px;\">                   \n",
       "q0_0: |0>──────────\n",
       "              ┌───┐\n",
       "q0_1: |0>─────┤ X ├\n",
       "         ┌───┐└───┘\n",
       "q1_0: |0>┤ X ├─────\n",
       "         └───┘     \n",
       "q1_1: |0>──────────\n",
       "                   </pre>"
      ],
      "text/plain": [
       "<qiskit.tools.visualization._text.TextDrawing at 0xa21916ba8>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circ2 = QuantumCircuit()\n",
    "circ2.add_register(q0)\n",
    "circ2.add_register(q1)\n",
    "circ2.x(q0[1])\n",
    "circ2.x(q1[0])\n",
    "circ2.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> The order of registers in the list is the order they are initiated or added (**not** the tensor product for quantum registers).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;line-height: 15px;\">                   \n",
       "q0_0: |0>──────────\n",
       "              ┌───┐\n",
       "q0_1: |0>─────┤ X ├\n",
       "         ┌───┐└───┘\n",
       "q1_0: |0>┤ X ├─────\n",
       "         └───┘     \n",
       "q1_1: |0>──────────\n",
       "                   \n",
       "q3_0: |0>──────────\n",
       "                   \n",
       "q3_1: |0>──────────\n",
       "                   </pre>"
      ],
      "text/plain": [
       "<qiskit.tools.visualization._text.TextDrawing at 0xa219316d8>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from copy import deepcopy\n",
    "\n",
    "q3 = QuantumRegister(2, 'q3')\n",
    "circ3 = deepcopy(circ)\n",
    "circ3.add_register(q3)\n",
    "circ3.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> The circuit drawer has the last register added at the bottom and if we add a new register it will add it to the bottom of the circuit. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extending a circuit\n",
    "\n",
    "In many situations you may have two circuits that you want to concatenate together to form a new circuit. This is very useful when one circuit has no measurements and the final circuit represents a measurement.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;line-height: 15px;\">                            ┌─┐\n",
       "q0_0: |0>───────────────────┤M├\n",
       "                    ┌───┐┌─┐└╥┘\n",
       "q0_1: |0>───────────┤ X ├┤M├─╫─\n",
       "            ┌───┐┌─┐└───┘└╥┘ ║ \n",
       "q1_0: |0>───┤ X ├┤M├──────╫──╫─\n",
       "         ┌─┐└───┘└╥┘      ║  ║ \n",
       "q1_1: |0>┤M├──────╫───────╫──╫─\n",
       "         └╥┘      ║       ║  ║ \n",
       " c0_0: 0 ═╬═══════╬═══════╬══╩═\n",
       "          ║       ║       ║    \n",
       " c0_1: 0 ═╬═══════╬═══════╩════\n",
       "          ║       ║            \n",
       " c1_0: 0 ═╬═══════╩════════════\n",
       "          ║                    \n",
       " c1_1: 0 ═╩════════════════════\n",
       "                               </pre>"
      ],
      "text/plain": [
       "<qiskit.tools.visualization._text.TextDrawing at 0xa21931dd8>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "meas = QuantumCircuit(q0, q1, c0, c1)\n",
    "meas.measure(q0, c0)\n",
    "meas.measure(q1, c1)\n",
    "\n",
    "qc = circ + meas\n",
    "\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;line-height: 15px;\">                            ┌─┐\n",
       "q0_0: |0>───────────────────┤M├\n",
       "                    ┌───┐┌─┐└╥┘\n",
       "q0_1: |0>───────────┤ X ├┤M├─╫─\n",
       "            ┌───┐┌─┐└───┘└╥┘ ║ \n",
       "q1_0: |0>───┤ X ├┤M├──────╫──╫─\n",
       "         ┌─┐└───┘└╥┘      ║  ║ \n",
       "q1_1: |0>┤M├──────╫───────╫──╫─\n",
       "         └╥┘      ║       ║  ║ \n",
       " c0_0: 0 ═╬═══════╬═══════╬══╩═\n",
       "          ║       ║       ║    \n",
       " c0_1: 0 ═╬═══════╬═══════╩════\n",
       "          ║       ║            \n",
       " c1_0: 0 ═╬═══════╩════════════\n",
       "          ║                    \n",
       " c1_1: 0 ═╩════════════════════\n",
       "                               </pre>"
      ],
      "text/plain": [
       "<qiskit.tools.visualization._text.TextDrawing at 0xa21947ac8>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "meas2 = QuantumCircuit()\n",
    "meas2.add_register(q0)\n",
    "meas2.add_register(q1)\n",
    "meas2.add_register(c0)\n",
    "meas2.add_register(c1)\n",
    "meas2.measure(q0, c0)\n",
    "meas2.measure(q1, c1)\n",
    "\n",
    "qc2 = circ2 + meas2\n",
    "\n",
    "qc2.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It even works when the circuits have different registers. Let's start by making two new circuits:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;line-height: 15px;\">              ┌───┐\n",
       "q1_0: |0>─────┤ X ├\n",
       "         ┌───┐└───┘\n",
       "q1_1: |0>┤ X ├─────\n",
       "         └───┘     </pre>"
      ],
      "text/plain": [
       "<qiskit.tools.visualization._text.TextDrawing at 0xa21931320>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circ4 = QuantumCircuit(q1)\n",
    "circ4.x(q1)\n",
    "circ4.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;line-height: 15px;\">              ┌───┐\n",
       "q3_0: |0>─────┤ H ├\n",
       "         ┌───┐└───┘\n",
       "q3_1: |0>┤ H ├─────\n",
       "         └───┘     </pre>"
      ],
      "text/plain": [
       "<qiskit.tools.visualization._text.TextDrawing at 0xa21947cf8>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circ5 = QuantumCircuit(q3)\n",
    "circ5.h(q3)\n",
    "circ5.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The new register is added to the circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;line-height: 15px;\">                        ┌───┐\n",
       "q1_0: |0>───────────────┤ X ├\n",
       "                   ┌───┐└───┘\n",
       "q1_1: |0>──────────┤ X ├─────\n",
       "              ┌───┐└───┘     \n",
       "q3_0: |0>─────┤ H ├──────────\n",
       "         ┌───┐└───┘          \n",
       "q3_1: |0>┤ H ├───────────────\n",
       "         └───┘               </pre>"
      ],
      "text/plain": [
       "<qiskit.tools.visualization._text.TextDrawing at 0xa21947978>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(circ4+circ5).draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have also overloaded `+=` to the `QuantumCircuit` object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;line-height: 15px;\">                        ┌───┐\n",
       "q1_0: |0>───────────────┤ X ├\n",
       "                   ┌───┐└───┘\n",
       "q1_1: |0>──────────┤ X ├─────\n",
       "              ┌───┐└───┘     \n",
       "q3_0: |0>─────┤ H ├──────────\n",
       "         ┌───┐└───┘          \n",
       "q3_1: |0>┤ H ├───────────────\n",
       "         └───┘               </pre>"
      ],
      "text/plain": [
       "<qiskit.tools.visualization._text.TextDrawing at 0xa20902940>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circ4 += circ5\n",
    "circ4.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Outcomes of Quantum Circuits\n",
    "\n",
    "In the circuit output, the most significant bit (MSB) is to the left and the least significant bit (LSB) is to the right (i.e. we follow the regular computer science little endian ordering). In this example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;line-height: 15px;\">                   \n",
       "q0_0: |0>──────────\n",
       "              ┌───┐\n",
       "q0_1: |0>─────┤ X ├\n",
       "         ┌───┐└───┘\n",
       "q1_0: |0>┤ X ├─────\n",
       "         └───┘     \n",
       "q1_1: |0>──────────\n",
       "                   </pre>"
      ],
      "text/plain": [
       "<qiskit.tools.visualization._text.TextDrawing at 0xa21947da0>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circ.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "qubit register $Q_0$ is prepared in the state $|10\\rangle$ and $Q_1$ is in the state $|01\\rangle$ giving a total state $|0110\\rangle$ ($Q1\\otimes Q0$). \n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> The tensor order in Qiskit goes as $Q_n \\otimes .. Q_1 \\otimes Q_0$\n",
    "</div>\n",
    "\n",
    "That is the four qubit statevector of length 16 with the 6th element (`int('0110',2)=6`) being one. Note the element count starts from zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j\n",
      " 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]\n"
     ]
    }
   ],
   "source": [
    "backend_sim = BasicAer.get_backend('statevector_simulator')\n",
    "result = execute(circ, backend_sim).result()\n",
    "state = result.get_statevector(circ)\n",
    "print(state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To check the fidelity of this state with the `basis_state` in Qiskit Terra you can use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state_fidelity(basis_state('0110', 4), state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use Qiskit Terra to make the unitary operator representing the circuit (provided there are no measurements). This will be a $16\\otimes16$ matrix equal to $I\\otimes X\\otimes X\\otimes I$. To check this is correct we can use the `Pauli` class and the `process_fidelity` function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backend_sim = BasicAer.get_backend('unitary_simulator')\n",
    "result = execute(circ, backend_sim).result()\n",
    "unitary = result.get_unitary(circ)\n",
    "process_fidelity(Pauli(label='IXXI').to_matrix(), unitary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To map the information of the quantum state to the classial world we have to use the example with measurements `qc`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;line-height: 15px;\">                            ┌─┐\n",
       "q0_0: |0>───────────────────┤M├\n",
       "                    ┌───┐┌─┐└╥┘\n",
       "q0_1: |0>───────────┤ X ├┤M├─╫─\n",
       "            ┌───┐┌─┐└───┘└╥┘ ║ \n",
       "q1_0: |0>───┤ X ├┤M├──────╫──╫─\n",
       "         ┌─┐└───┘└╥┘      ║  ║ \n",
       "q1_1: |0>┤M├──────╫───────╫──╫─\n",
       "         └╥┘      ║       ║  ║ \n",
       " c0_0: 0 ═╬═══════╬═══════╬══╩═\n",
       "          ║       ║       ║    \n",
       " c0_1: 0 ═╬═══════╬═══════╩════\n",
       "          ║       ║            \n",
       " c1_0: 0 ═╬═══════╩════════════\n",
       "          ║                    \n",
       " c1_1: 0 ═╩════════════════════\n",
       "                               </pre>"
      ],
      "text/plain": [
       "<qiskit.tools.visualization._text.TextDrawing at 0xa20902cf8>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will map the quantum state to the classical world and since the state has no superpositions it will be deterministic and equal to `'01 10'`.  Here a space is used to separate the registers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'01 10': 1024}\n"
     ]
    }
   ],
   "source": [
    "backend_sim = BasicAer.get_backend('qasm_simulator')\n",
    "result = execute(qc, backend_sim).result()\n",
    "counts = result.get_counts(qc)\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To show that it does not matter how you add the registers we run the same as above on the second example circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "backend_sim = BasicAer.get_backend('statevector_simulator')\n",
    "result = execute(circ2, backend_sim).result()\n",
    "states = result.get_statevector(circ2)\n",
    "\n",
    "backend_sim = BasicAer.get_backend('qasm_simulator')\n",
    "result = execute(qc2, backend_sim).result()\n",
    "counts = result.get_counts(qc2)\n",
    "\n",
    "backend_sim = BasicAer.get_backend('unitary_simulator')\n",
    "result = execute(circ2, backend_sim).result()\n",
    "unitary = result.get_unitary(circ2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'01 10': 1024}\n"
     ]
    }
   ],
   "source": [
    "print(counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state_fidelity(basis_state('0110', 4), state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "process_fidelity(Pauli(label='IXXI').to_matrix(), unitary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Counting circuit resources\n",
    "\n",
    "A `QuantumCircuit` object provides methods for inquiring its resource use. This includes the number of qubits, operations, and a few other things."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;line-height: 15px;\">                   ┌───┐               ┌───┐                    \n",
       "q0_0: |0>──────────┤ H ├──■────────────┤ X ├────────────────────\n",
       "                   └───┘  │            └───┘               ┌───┐\n",
       "q0_1: |0>─────────────────■───────────────────■────────────┤ X ├\n",
       "                        ┌─┴─┐┌───┐┌───┐       │            └───┘\n",
       "q0_2: |0>───────────────┤ X ├┤ X ├┤ H ├───────┼─────────────────\n",
       "                        └───┘└───┘└───┘     ┌─┴─┐┌───┐┌───┐     \n",
       "q0_3: |0>───────────────────────────────────┤ X ├┤ X ├┤ H ├─────\n",
       "              ┌───┐                         └───┘└───┘└───┘     \n",
       "q0_4: |0>─────┤ X ├─────────────────────────────────────────────\n",
       "         ┌───┐└───┘                                             \n",
       "q0_5: |0>┤ X ├──────────────────────────────────────────────────\n",
       "         └───┘                                                  </pre>"
      ],
      "text/plain": [
       "<qiskit.tools.visualization._text.TextDrawing at 0xa220091d0>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q = QuantumRegister(6)\n",
    "circuit = QuantumCircuit(q)\n",
    "circuit.h(q[0])\n",
    "circuit.ccx(q[0], q[1], q[2])\n",
    "circuit.cx(q[1], q[3])\n",
    "circuit.x(q)\n",
    "circuit.h(q[2])\n",
    "circuit.h(q[3])\n",
    "circuit.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# total number of operations in the circuit. no unrolling is done.\n",
    "circuit.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# depth of circuit (number of ops on the critical path)\n",
    "circuit.depth()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# number of qubits in the circuit\n",
    "circuit.width()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'x': 6, 'h': 3, 'ccx': 1, 'cx': 1}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a breakdown of operations by type\n",
    "circuit.count_ops()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# number of unentangled subcircuits in this circuit.\n",
    "# each subcircuit can in principle be executed on a different quantum processor!\n",
    "circuit.num_tensor_factors()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}