qiskit/advanced/terra/1_advanced_circuits.ipynb

{
 "cells": [
  {
   "attachments": {
    "qiskit_header.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![qiskit_header.png](attachment:qiskit_header.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Terra 0.8 - Circuit API Updates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial, we'll introduce three new components of the Terra circuit-building API added in the Terra 0.8 release. Their purpose is to facilitate circuit construction, reduce boilerplate, and aid reuse through composition and parameterization. These three new components are:\n",
    "\n",
    " 1. [Optional register declarations](#1.-Optional-register-declarations)\n",
    " 2. [Portable `Instruction`s and `CompositeGate` replacement](#2.-Portable-Instructions-and-CompositeGate-replacement)\n",
    " 3. [Parameterized Circuit](#3.-Parameterized-circuits)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-21T09:00:47.649701Z",
     "start_time": "2019-08-21T09:00:45.301727Z"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Optional registers\n",
    "\n",
    "For circuits that require only a single register, register declarations can amount to unneeded overhead.\n",
    "Terra 0.8 adds more concise syntax to create and build circuits without explicit register declaration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Registerless `QuantumCircuit` declaration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An alternate constructor has been added to `QuantumCircuit` that accepts one or two integers: the number of qubits (required), and the number of classical bits (optional)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-21T09:00:47.654546Z",
     "start_time": "2019-08-21T09:00:47.651707Z"
    }
   },
   "outputs": [],
   "source": [
    "qc = QuantumCircuit(3, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will create a quantum circuit equivalent to the following (still valid) circuit declaration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-21T09:00:47.661925Z",
     "start_time": "2019-08-21T09:00:47.656456Z"
    }
   },
   "outputs": [],
   "source": [
    "qr = QuantumRegister(3, name='q')\n",
    "cr = ClassicalRegister(2, name='c')\n",
    "qc = QuantumCircuit(qr, cr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Registers are created automatically and can be accessed through the circuit as needed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T14:45:17.091163Z",
     "start_time": "2019-08-22T14:45:17.087876Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[QuantumRegister(3, 'q')]\n",
      "[ClassicalRegister(2, 'c')]\n"
     ]
    }
   ],
   "source": [
    "print(qc.qregs)\n",
    "print(qc.cregs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quantum/classical bit index-based addressing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the spirit of register-less circuits, qubits and classical bits (clbits) can now be addressed directly by index, without a need for referencing a register.\n",
    "In the following example, `bell.h(0)` attaches a Hadamard gate to the first quantum bit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T14:45:17.109351Z",
     "start_time": "2019-08-22T14:45:17.093211Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌───┐     ┌─┐   \n",
       "q_0: |0>┤ H ├──■──┤M├───\n",
       "        └───┘┌─┴─┐└╥┘┌─┐\n",
       "q_1: |0>─────┤ X ├─╫─┤M├\n",
       "             └───┘ ║ └╥┘\n",
       " c_0: 0 ═══════════╩══╬═\n",
       "                      ║ \n",
       " c_1: 0 ══════════════╩═\n",
       "                        </pre>"
      ],
      "text/plain": [
       "<qiskit.visualization.text.TextDrawing at 0x1f419de9c48>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bell = QuantumCircuit(2, 2)\n",
    "bell.h(0)\n",
    "bell.cx(0, 1)\n",
    "bell.measure([0,1], [0,1])\n",
    "\n",
    "bell.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The gate's argument types will determine if an index references a qubit or a clbit (e.g. `cx` expects `(qubit, qubit)`; `measure` expects `(qubit, clbit)`).\n",
    "This syntax works with both forms of `QuantumCircuit` construction, and users can switch between register-based and index-based commands as convenient."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In circuits with multiple registers, index ordering will be set by the order in which registers were added to the circuit, and can be verified by inspecting the circuit's `qubits` and `clbits` properties."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T14:45:17.121482Z",
     "start_time": "2019-08-22T14:45:17.111498Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Qubit ordering: [Qubit(QuantumRegister(1, 'q2'), 0), Qubit(QuantumRegister(1, 'q1'), 0)]\n",
      "Classical bit ordering: [Clbit(ClassicalRegister(2, 'c'), 0), Clbit(ClassicalRegister(2, 'c'), 1)]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">         ┌───┐      \n",
       "q2_0: |0>┤ H ├──────\n",
       "         ├───┤┌─┐┌─┐\n",
       "q1_0: |0>┤ H ├┤M├┤M├\n",
       "         └───┘└╥┘└╥┘\n",
       "  c_0: 0 ══════╩══╬═\n",
       "                  ║ \n",
       "  c_1: 0 ═════════╩═\n",
       "                    </pre>"
      ],
      "text/plain": [
       "<qiskit.visualization.text.TextDrawing at 0x1f419e0db48>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qr1 = QuantumRegister(1, 'q1')\n",
    "qr2 = QuantumRegister(1, 'q2')\n",
    "cr = ClassicalRegister(2, 'c')\n",
    "circuit = QuantumCircuit(qr2, qr1, cr)\n",
    "\n",
    "print('Qubit ordering:', circuit.qubits)\n",
    "print('Classical bit ordering:', circuit.clbits)\n",
    "\n",
    "circuit.h([1,0])\n",
    "circuit.measure(1, [0,1])\n",
    "circuit.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Portable `Instruction`s and `CompositeGate` replacement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Starting with Terra 0.8, `Instruction` instances have become more portable and serve as the basis for composing re-usable circuit components through the new `append` method on `QuantumCircuit`s."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-24T04:16:16.208643Z",
     "start_time": "2019-04-24T04:16:16.205855Z"
    }
   },
   "source": [
    "### Opaque gates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Gate` and `Instruction` constructors have been updated to accept an integer number of qubits (`num_qubits`) and an integer number of classical bits (`num_cbits`), which define the gate's quantum and classical width."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-21T09:00:47.692387Z",
     "start_time": "2019-08-21T09:00:47.689669Z"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit.circuit import Gate\n",
    "\n",
    "my_gate = Gate(name='my_gate', num_qubits=2, params=[])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-24T14:15:12.883919Z",
     "start_time": "2019-04-24T14:15:12.878579Z"
    }
   },
   "source": [
    "An `append(instruction, qargs, cargs)` method has been added to the `QuantumCircuit` class, which takes an anonymous `Instruction` instance and attaches it to the circuit at the specified `qargs` and `cargs`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T14:45:17.137276Z",
     "start_time": "2019-08-22T14:45:17.129509Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌──────────┐            \n",
       "q_0: |0>┤0         ├────────────\n",
       "        │  my_gate │┌──────────┐\n",
       "q_1: |0>┤1         ├┤0         ├\n",
       "        └──────────┘│  my_gate │\n",
       "q_2: |0>────────────┤1         ├\n",
       "                    └──────────┘</pre>"
      ],
      "text/plain": [
       "<qiskit.visualization.text.TextDrawing at 0x1f419e10fc8>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qr = QuantumRegister(3, 'q')\n",
    "circ = QuantumCircuit(qr)\n",
    "circ.append(my_gate, [qr[0], qr[1]])\n",
    "circ.append(my_gate, [qr[1], qr[2]])\n",
    "\n",
    "circ.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Composite Gates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Composite gates and complex circuit components can now be constructed and managed as independent `QuantumCircuit`s and, through the `to_instruction` method, converted to `Instruction`s to be appended to a target circuit at a given location."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T14:45:17.152693Z",
     "start_time": "2019-08-22T14:45:17.139151Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌───┐                       \n",
       "q_0: |0>┤ H ├──■────────────────────\n",
       "        └───┘┌─┴─┐     ┌───────────┐\n",
       "q_1: |0>─────┤ X ├──■──┤0          ├\n",
       "             └───┘┌─┴─┐│  sub_circ │\n",
       "q_2: |0>──────────┤ X ├┤1          ├\n",
       "                  └───┘└───────────┘</pre>"
      ],
      "text/plain": [
       "<qiskit.visualization.text.TextDrawing at 0x1f419e2b748>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Build a sub-circuit\n",
    "sub_q = QuantumRegister(2)\n",
    "sub_circ = QuantumCircuit(sub_q, name='sub_circ')\n",
    "sub_circ.h(sub_q[0])\n",
    "sub_circ.crz(1, sub_q[0], sub_q[1])\n",
    "sub_circ.barrier()\n",
    "sub_circ.iden(sub_q[1])\n",
    "sub_circ.u3(1, 2, -2, sub_q[0])\n",
    "\n",
    "# Convert to a gate and stick it into an arbitrary place in the bigger circuit\n",
    "sub_inst = sub_circ.to_instruction()\n",
    "\n",
    "q = QuantumRegister(3, 'q')\n",
    "circ = QuantumCircuit(q)\n",
    "circ.h(qr[0])\n",
    "circ.cx(qr[0], qr[1])\n",
    "circ.cx(qr[1], qr[2])\n",
    "circ.append(sub_inst, [q[1], q[2]])\n",
    "\n",
    "circ.draw()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Circuits are not immediately decomposed upon conversion `to_instruction` to allow circuit design at higher levels of abstraction.\n",
    "When desired, or before compilation, sub-circuits will be decomposed via the `decompose` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T14:45:17.178354Z",
     "start_time": "2019-08-22T14:45:17.154448Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌──────────┐                                         \n",
       "q_0: |0>┤ U2(0,pi) ├──■──────────────────────────────────────\n",
       "        └──────────┘┌─┴─┐     ┌───┐          ░ ┌────────────┐\n",
       "q_1: |0>────────────┤ X ├──■──┤ H ├────■─────░─┤ U3(1,2,-2) ├\n",
       "                    └───┘┌─┴─┐└───┘┌───┴───┐ ░ └───┬────┬───┘\n",
       "q_2: |0>─────────────────┤ X ├─────┤ Rz(1) ├─░─────┤ Id ├────\n",
       "                         └───┘     └───────┘ ░     └────┘    </pre>"
      ],
      "text/plain": [
       "<qiskit.visualization.text.TextDrawing at 0x1f419e2a9c8>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decomposed_circ = circ.decompose() # Does not modify original circuit\n",
    "decomposed_circ.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Parameterized circuits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parameterization is a common feature of many quantum algorithms, as well as a standard building block for constructing libraries of standard gates and subcircuits.\n",
    "\n",
    "Terra 0.8 introduces a `Parameter` class that can be used to specify a placeholder wherever a numeric parameter can be used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following example, we want to quickly construct a series of experiments that vary the angle of a global $R_z$ rotation over a set of entangled qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T14:45:17.201634Z",
     "start_time": "2019-08-22T14:45:17.180844Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌───┐                     ░ ┌───────┐ ░                     ┌───┐┌─┐\n",
       "q_0: |0>┤ H ├──■──────────────────░─┤ Rz(θ) ├─░──────────────────■──┤ H ├┤M├\n",
       "        └───┘┌─┴─┐                ░ ├───────┤ ░                ┌─┴─┐└───┘└╥┘\n",
       "q_1: |0>─────┤ X ├──■─────────────░─┤ Rz(θ) ├─░─────────────■──┤ X ├──────╫─\n",
       "             └───┘┌─┴─┐           ░ ├───────┤ ░           ┌─┴─┐└───┘      ║ \n",
       "q_2: |0>──────────┤ X ├──■────────░─┤ Rz(θ) ├─░────────■──┤ X ├───────────╫─\n",
       "                  └───┘┌─┴─┐      ░ ├───────┤ ░      ┌─┴─┐└───┘           ║ \n",
       "q_3: |0>───────────────┤ X ├──■───░─┤ Rz(θ) ├─░───■──┤ X ├────────────────╫─\n",
       "                       └───┘┌─┴─┐ ░ ├───────┤ ░ ┌─┴─┐└───┘                ║ \n",
       "q_4: |0>────────────────────┤ X ├─░─┤ Rz(θ) ├─░─┤ X ├─────────────────────╫─\n",
       "                            └───┘ ░ └───────┘ ░ └───┘                     ║ \n",
       " c_0: 0 ══════════════════════════════════════════════════════════════════╩═\n",
       "                                                                            </pre>"
      ],
      "text/plain": [
       "<qiskit.visualization.text.TextDrawing at 0x1f41a180b88>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.circuit import Parameter\n",
    "\n",
    "theta = Parameter('θ')\n",
    "\n",
    "n = 5\n",
    "\n",
    "qc = QuantumCircuit(5, 1)\n",
    "\n",
    "qc.h(0)\n",
    "for i in range(n-1):\n",
    "    qc.cx(i, i+1)\n",
    "\n",
    "qc.barrier()\n",
    "qc.rz(theta, range(5))\n",
    "qc.barrier()\n",
    "\n",
    "for i in reversed(range(n-1)):\n",
    "    qc.cx(i, i+1)\n",
    "qc.h(0)\n",
    "qc.measure(0, 0)\n",
    "\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-07T13:51:25.524355Z",
     "start_time": "2019-05-07T13:51:25.518233Z"
    }
   },
   "source": [
    "We can inspect the circuit's parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T14:45:17.206387Z",
     "start_time": "2019-08-22T14:45:17.203148Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{Parameter(θ)}\n"
     ]
    }
   ],
   "source": [
    "print(qc.parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Binding parameters to values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All circuit parameters must be bound before sending the circuit to a backend. This can be done in one of two ways:\n",
    "- The `bind_parameters` method accepts a dictionary mapping `Parameter`s to values, and returns a new circuit with each parameter replaced by its corresponding value. Partial binding is supported, in which case the returned circuit will be parameterized by any `Parameter`s that were not mapped to a value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T14:45:17.572833Z",
     "start_time": "2019-08-22T14:45:17.209134Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        ┌───┐                     ░ ┌─────────┐ ░                     ┌───┐┌─┐\n",
      "q_0: |0>┤ H ├──■──────────────────░─┤ Rz(2pi) ├─░──────────────────■──┤ H ├┤M├\n",
      "        └───┘┌─┴─┐                ░ ├─────────┤ ░                ┌─┴─┐└───┘└╥┘\n",
      "q_1: |0>─────┤ X ├──■─────────────░─┤ Rz(2pi) ├─░─────────────■──┤ X ├──────╫─\n",
      "             └───┘┌─┴─┐           ░ ├─────────┤ ░           ┌─┴─┐└───┘      ║ \n",
      "q_2: |0>──────────┤ X ├──■────────░─┤ Rz(2pi) ├─░────────■──┤ X ├───────────╫─\n",
      "                  └───┘┌─┴─┐      ░ ├─────────┤ ░      ┌─┴─┐└───┘           ║ \n",
      "q_3: |0>───────────────┤ X ├──■───░─┤ Rz(2pi) ├─░───■──┤ X ├────────────────╫─\n",
      "                       └───┘┌─┴─┐ ░ ├─────────┤ ░ ┌─┴─┐└───┘                ║ \n",
      "q_4: |0>────────────────────┤ X ├─░─┤ Rz(2pi) ├─░─┤ X ├─────────────────────╫─\n",
      "                            └───┘ ░ └─────────┘ ░ └───┘                     ║ \n",
      " c_0: 0 ════════════════════════════════════════════════════════════════════╩═\n",
      "                                                                              \n",
      "set()\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "theta_range = np.linspace(0, 2 * np.pi, 128)\n",
    "\n",
    "circuits = [qc.bind_parameters({theta: theta_val})\n",
    "            for theta_val in theta_range]\n",
    "\n",
    "print(circuits[-1].draw(fold=120))\n",
    "print(circuits[-1].parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `qiskit.execute` now accepts a `parameter_binds` keyword argument which, when specified as a list of dictionaries mapping `Parameter`s to values, will bind and execute a circuit on the backend for every mapping dictionary in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-21T09:00:53.482684Z",
     "start_time": "2019-08-21T09:00:52.013988Z"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit import BasicAer, execute\n",
    "\n",
    "job = execute(qc,\n",
    "              backend=BasicAer.get_backend('qasm_simulator'),\n",
    "              parameter_binds=[{theta: theta_val} for theta_val in theta_range])\n",
    "\n",
    "# Note: Bind labels are not presrved in executed experiments.\n",
    "counts = [job.result().get_counts(i) for i in range(len(job.result().results))]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example circuit, we apply a global $R_z(\\theta)$ rotation on a five-qubit entangled state, and so expect to see oscillation in qubit-0 at $5\\theta$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T14:45:19.578574Z",
     "start_time": "2019-08-22T14:45:19.166876Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1f41a13a948>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(8,6))\n",
    "ax = fig.add_subplot(111)\n",
    "\n",
    "ax.plot(theta_range, list(map(lambda c: c.get('0', 0), counts)), '.-', label='0')\n",
    "ax.plot(theta_range, list(map(lambda c: c.get('1', 0), counts)), '.-', label='1') \n",
    "\n",
    "ax.set_xticks([i * np.pi / 2 for i in range(5)])\n",
    "ax.set_xticklabels(['0', r'$\\frac{\\pi}{2}$', r'$\\pi$', r'$\\frac{3\\pi}{2}$', r'$2\\pi$'], fontsize=14)\n",
    "ax.set_xlabel('θ')\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-24T14:50:01.020312Z",
     "start_time": "2019-04-24T14:49:58.618Z"
    }
   },
   "source": [
    "### Reducing compilation cost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compiling over a parameterized circuit prior to binding can, in some cases, significantly reduce compilation time as compared to compiling over a set of bound circuits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T14:45:41.843339Z",
     "start_time": "2019-08-22T14:45:19.579877Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time compiling over set of bound circuits:  43.828014850616455\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "from itertools import combinations\n",
    "from qiskit.compiler import transpile, assemble\n",
    "from qiskit.test.mock import FakeTokyo\n",
    "\n",
    "start = time.time()\n",
    "qcs = []\n",
    "\n",
    "theta_range = np.linspace(0, 2*np.pi, 32)\n",
    "\n",
    "for n in theta_range:\n",
    "    qc = QuantumCircuit(5)\n",
    "\n",
    "    for k in range(8):\n",
    "        for i,j in combinations(range(5), 2):\n",
    "            qc.cx(i,j)\n",
    "        qc.rz(n, range(5))\n",
    "        for i,j in combinations(range(5), 2):\n",
    "            qc.cx(i,j)\n",
    "\n",
    "    qcs.append(qc)\n",
    "    \n",
    "compiled_circuits = transpile(qcs, backend=FakeTokyo())\n",
    "qobj = assemble(compiled_circuits, backend=FakeTokyo())\n",
    "\n",
    "end = time.time()\n",
    "print('Time compiling over set of bound circuits: ', end-start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T14:45:46.361352Z",
     "start_time": "2019-08-22T14:45:41.846044Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time compiling over parameterized circuit, then binding:  3.453131675720215\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "qc = QuantumCircuit(5)\n",
    "theta = Parameter('theta')\n",
    "\n",
    "for k in range(8):\n",
    "    for i,j in combinations(range(5), 2):\n",
    "        qc.cx(i,j)\n",
    "    qc.rz(theta, range(5))\n",
    "    for i,j in combinations(range(5), 2):\n",
    "        qc.cx(i,j)\n",
    "\n",
    "transpiled_qc = transpile(qc, backend=FakeTokyo())\n",
    "qobj = assemble([transpiled_qc.bind_parameters({theta: n})\n",
    "                 for n in theta_range], backend=FakeTokyo())\n",
    "end = time.time()\n",
    "print('Time compiling over parameterized circuit, then binding: ', end-start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Composition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parameterized circuits can be composed like standard `QuantumCircuit`s.\n",
    "Generally, when composing two parameterized circuits, the resulting circuit will be parameterized by the union of the parameters of the input circuits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-08T15:07:47.268889Z",
     "start_time": "2019-05-08T15:07:47.262971Z"
    }
   },
   "source": [
    "However, parameter names must be unique within a given circuit.\n",
    "When attempting to add a parameter whose name is already present in the target circuit:\n",
    " - if the source and target share the same `Parameter` instance, the parameters will be assumed to be the same and combined\n",
    " - if the source and target have different `Parameter` instances, an error will be raised\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T14:45:46.372951Z",
     "start_time": "2019-08-22T14:45:46.362798Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        ┌────────────┐┌────────────┐\n",
      "q_0: |0>┤0           ├┤0           ├\n",
      "        │  sc_1(phi) ││  sc_2(phi) │\n",
      "q_1: |0>┤1           ├┤1           ├\n",
      "        ├────────────┤└────────────┘\n",
      "q_2: |0>┤0           ├──────────────\n",
      "        │  sc_2(phi) │              \n",
      "q_3: |0>┤1           ├──────────────\n",
      "        └────────────┘              \n"
     ]
    }
   ],
   "source": [
    "phi = Parameter('phi')\n",
    "\n",
    "sub_circ1 = QuantumCircuit(2, name='sc_1')\n",
    "sub_circ1.rz(phi, 0)\n",
    "sub_circ1.rx(phi, 1)\n",
    "\n",
    "sub_circ2 = QuantumCircuit(2, name='sc_2')\n",
    "sub_circ2.rx(phi, 0)\n",
    "sub_circ2.rz(phi, 1)\n",
    "\n",
    "qc = QuantumCircuit(4)\n",
    "qr = qc.qregs[0]\n",
    "\n",
    "qc.append(sub_circ1.to_instruction(), [qr[0], qr[1]])\n",
    "qc.append(sub_circ2.to_instruction(), [qr[0], qr[1]])\n",
    "\n",
    "qc.append(sub_circ2.to_instruction(), [qr[2], qr[3]])\n",
    "\n",
    "print(qc.draw())\n",
    "\n",
    "# The following raises an error: \"QiskitError: 'Name conflict on adding parameter: phi'\"\n",
    "# phi2 = Parameter('phi')\n",
    "# qc.u3(0.1, phi2, 0.3, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To insert a subcircuit under a different parameterization, the `to_instruction` method accepts an optional argument (`parameter_map`) which, when present, will generate instructions with the source parameter replaced by a new parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T14:45:46.401332Z",
     "start_time": "2019-08-22T14:45:46.375034Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          ┌────────────────┐\n",
      "q19_0: |0>┤0               ├\n",
      "          │                │\n",
      "q19_1: |0>┤1 oracle(theta) ├\n",
      "          │                │\n",
      "q19_2: |0>┤2               ├\n",
      "          └┬──────────────┬┘\n",
      "q19_3: |0>─┤0             ├─\n",
      "           │              │ \n",
      "q19_4: |0>─┤1 oracle(phi) ├─\n",
      "           │              │ \n",
      "q19_5: |0>─┤2             ├─\n",
      "          ┌┴──────────────┴┐\n",
      "q19_6: |0>┤0               ├\n",
      "          │                │\n",
      "q19_7: |0>┤1 oracle(gamma) ├\n",
      "          │                │\n",
      "q19_8: |0>┤2               ├\n",
      "          └────────────────┘\n",
      "          ┌───────────┐                                    \n",
      "q19_0: |0>┤ Rz(theta) ├──■─────────────────────────────────\n",
      "          └───────────┘┌─┴─┐┌───────────┐                  \n",
      "q19_1: |0>─────────────┤ X ├┤ Rz(theta) ├──■───────────────\n",
      "                       └───┘└───────────┘┌─┴─┐┌───────────┐\n",
      "q19_2: |0>───────────────────────────────┤ X ├┤ Rz(theta) ├\n",
      "           ┌─────────┐                   └───┘└───────────┘\n",
      "q19_3: |0>─┤ Rz(phi) ├───■─────────────────────────────────\n",
      "           └─────────┘ ┌─┴─┐ ┌─────────┐                   \n",
      "q19_4: |0>─────────────┤ X ├─┤ Rz(phi) ├───■───────────────\n",
      "                       └───┘ └─────────┘ ┌─┴─┐ ┌─────────┐ \n",
      "q19_5: |0>───────────────────────────────┤ X ├─┤ Rz(phi) ├─\n",
      "          ┌───────────┐                  └───┘ └─────────┘ \n",
      "q19_6: |0>┤ Rz(gamma) ├──■─────────────────────────────────\n",
      "          └───────────┘┌─┴─┐┌───────────┐                  \n",
      "q19_7: |0>─────────────┤ X ├┤ Rz(gamma) ├──■───────────────\n",
      "                       └───┘└───────────┘┌─┴─┐┌───────────┐\n",
      "q19_8: |0>───────────────────────────────┤ X ├┤ Rz(gamma) ├\n",
      "                                         └───┘└───────────┘\n"
     ]
    }
   ],
   "source": [
    "p = Parameter('p')\n",
    "qc = QuantumCircuit(3, name='oracle')\n",
    "qc.rz(p, 0)\n",
    "qc.cx(0, 1)\n",
    "qc.rz(p, 1)\n",
    "qc.cx(1, 2)\n",
    "qc.rz(p, 2)\n",
    "\n",
    "theta = Parameter('theta')\n",
    "phi = Parameter('phi')\n",
    "gamma = Parameter('gamma')\n",
    "\n",
    "qr = QuantumRegister(9)\n",
    "larger_qc = QuantumCircuit(qr)\n",
    "larger_qc.append(qc.to_instruction({p: theta}), qr[0:3])\n",
    "larger_qc.append(qc.to_instruction({p: phi}), qr[3:6])\n",
    "larger_qc.append(qc.to_instruction({p: gamma}), qr[6:9])\n",
    "print(larger_qc.draw())\n",
    "\n",
    "print(larger_qc.decompose().draw())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T14:45:46.489770Z",
     "start_time": "2019-08-22T14:45:46.403279Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td>Qiskit</td><td>0.14.0</td></tr><tr><td>Terra</td><td>0.11.0</td></tr><tr><td>Aer</td><td>0.3.4</td></tr><tr><td>Ignis</td><td>0.2.0</td></tr><tr><td>Aqua</td><td>0.6.1</td></tr><tr><td>IBM Q Provider</td><td>0.4.4</td></tr><tr><th>System information</th></tr><tr><td>Python</td><td>3.7.4 (default, Aug  9 2019, 18:34:13) [MSC v.1915 64 bit (AMD64)]</td></tr><tr><td>OS</td><td>Windows</td></tr><tr><td>CPUs</td><td>2</td></tr><tr><td>Memory (Gb)</td><td>7.9987335205078125</td></tr><tr><td colspan='2'>Tue Dec 10 16:07:14 2019 Eastern Standard Time</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2019.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import qiskit.tools.jupyter\n",
    "%qiskit_version_table\n",
    "%qiskit_copyright"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}