diff --git a/tutorials/circuit.ipynb b/tutorials/circuit.ipynb new file mode 100644 index 0000000..a29ceed --- /dev/null +++ b/tutorials/circuit.ipynb @@ -0,0 +1,581 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Constructing Quantum Circuits in QuAIRKit\n", + "\n", + "QuAIRKit uses the `Circuit` class to represent quantum circuits. In this tutorial, we will learn how to manipulate quantum circuits in QuAIRKit.\n", + "\n", + "**Table of Contents**\n", + "\n", + "- [Constructing quantum circuits](#Constructing-Quantum-Circuits)\n", + " - [Add operations](#Add-operaions)\n", + " - [Add circuit templates](#Add-circuit-templates)\n", + " - [Operator management](#Operator-management)\n", + " - [Execution](#Execution)\n", + "- [Other properties](#Other-properties)\n", + "- [Training noisy ground state preparation](Training-noisy-ground-state-preparation)" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "from quairkit import Circuit\n", + "from quairkit.database import *\n", + "from quairkit.operator import RZ\n", + "from quairkit.qinfo import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Constructing quantum circuits\n", + "\n", + "In QuAIRKit, circuits can be generated with or without specifying the total number of qubits." + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [], + "source": [ + "num_qubits = 3\n", + "\n", + "cir = Circuit() # Create a dynamic circuit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Add gates\n", + "\n", + "Constant gates can be directly called from the attributes of the `Circuit` class. The semantic rule for specifying the locations added operations is as follows:\n", + "\n", + "- No inputs: The operations are added across all qubits.\n", + "- `int`: The single-qubit operation is added to the specified qubit.\n", + "- `List[int]`: The single-qubit operation is added across the specified qubits, or the multi-qubit operation is added across the specified qubits.\n", + "- `List[List[int]]`: The multi-qubit operation is added across different groups of specified qubits.\n", + "\n", + "```python" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUsAAACyCAYAAADLXe37AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAWWklEQVR4nO3dfUwb5x0H8C8vPrsYnEWlwUp5Cem6VqhZpipG7VStJJuqZY220UmRuiVTk6YRXbWooV3KSDTKBtkW1C1sjCQqAqUhAWkj0RrK2MRCFk1tlSiJmq6p2r3Q4UBJQpcaw2ob8G9/rCBeDDxn+8zZfD/SCel89/weP2d/ffjOd0kiIiAionklL3YHiIjiAcOSiEgBw5KISAHDkohIAcOSiEgBw5KISAHDkohIAcOSiEgBw5KISAHDkohIAcOSiEgBw5KISAHDkohIAcOSiEhBaqwL+nw+BAIBQ2tomgabzaZ7PTP3bSng+CeORNyWMQ1Ln8+H/Px8DAwMGFrH6XSip6dH10CauW9LAcc/cSTqtoxpWAYCAQwMDMDtdsPhcBhSY2hoCDk5OQgEAroG0cx9Wwo4/okjUbdlzP8NBwCHw2HYIEbKzH1bCjj+iSPRtiUP8BARKWBYEhEpYFgSESlgWBIRKWBYEhEpYFgSESlgWBIRKWBYEhEpYFgSESlgWBIRKWBYki7t7e0IBoNKy7rdbly+fNngHhHFBsOSlA0NDeHZZ59FSUnJgoHpdruxfv16NDc3x6h3RMYybVjm5+fjpZdemjV/3bp1qKioWIQe/f/SU3feeSdefvnlyXnBYBCPP/441q1bB6/Xuyj9ihWHw4Hu7m6cOXNm3sCcCMoNGzagpqYmavVbWlqQnp4+a7JYLEhKSsKFCxeiVouM5ff7kZubi/3790+b39fXh/z8fFRVVS1Sz+YhMeTxeASAeDyeeZe7efOmAJCurq5p80dHR8VqtUp7e3vENcJdr66uTvLy8sTv94uIyNNPPy333HOP3Lx5M2o1QnG73XL48GFpamqS//znP7rXj6be3l6566675KmnnpLx8XHlx+YT7ticO3dOHA6HlJWVGVZDVTAYlDNnzsivf/1r+dOf/qTr+ScS1XE+cuSIZGZmyvDwsIiIDA4OSkFBgezevTtqNaLJlGHZ0dEhAGRwcHDa/CtXrggAuXHjRsQ1wl3P7/dLXl6e1NfXy759+yQnJ0d6e3ujWmOmX/3qV5KSkiJpaWmSlpYmVqtVXnvtNV1tRFuoUAw3KEXCG5vOzk5JS0uTqqoqw2qoGhoaEpfLJVardXIbrV27Vm7duhX1WmanOs6jo6OyevVqqampEa/XK4WFhbJt2zYJBoNRqxFNpgzLF198UbKzs2fNf+WVV2TVqlVRqRHJeg0NDWK32yUzM1PeffddQ2pMeP/99yUlJUUATJvS0tImP5EXy9Rw/OCDD8IOShH9Y9PW1iZWq1Vqa2sNq6FHaWmpWK3WadtI0zTZuXNn1GuZnZ5xPnr0qGRlZcmGDRukuLhYxsbGol4jWpQv/js0NBT+//o627hw4QIGBgaQmZk5bf4nn3yCTZs2RbVWuMuPjIygtLQU9957r6719NY6fvw4UlNTMT4+Pm2+iODVV1/Fo48+qrt+tCxbtgyvvvoqvvrVr6KlpQWPPfYYDhw4gOHhYd1t6RmTY8eOYceOHTh06BC2b99uaC09ffL7/dPmBQIBtLa2RvV723igZ3y3bNmCyspK+Hw+dHR0ICUlxbBac1G+QLFqqmLGnk0k00KfBitWrJC9e/eK2+2eNq1du1ZqamrmXXfiE8eovp08eVLS09PlmWeekRUrVsjIyIjqEEbct6UwLTT+9fX1ommatLa2Ko87x9+c23LCypUrpb6+ftG2pSrlPUuPx6O66Jwm7psxn3//+9+4ceMGHnnkEWRnZ0/O/+STT3D16lUUFhYq1dJ7/w+VvnV1dWHr1q1obW3Fxo0b0dXVhbq6OuzZs0e5jt6+/fOf/4TL5Zq1Z5mWloZ//OMfsNvtumpH07Vr17Bp0yY8+OCDOHHiBPLy8lBUVISDBw8iOVnfiRYq43/gwAFUVFSgra1N+T+MUIy4N0x5eTkaGhqm7V1aLBZ85zvfQW1tbVRrmZ3KtpzQ19eH/v5+uFyusGoZeZ+fWXTFeYRUvmf47W9/KxaLRf773/9Om3/27FlJSUlZ8Hs6o76zfOONNyQjI0Oam5sn57W0tEhmZqZ4vd6o1JjL1AM8AEx3gOfWrVsCQN555x3DDvDs3btX7Hb7rDMkolkjEl6vV1wul2iaJrfddpsAkDVr1vAAzwJOnTolmqZNnl1iRI1oMV1Y7tmzRwoLC2fNr66uljVr1kSlht71rly5IsuXL5e6urpp88fHx+W+++6T6urqiGssxO12yy9/+UsBIB988IHu9aNp5lHvqc/LiFOHLl68KAAkNTVV7Hb7rGnz5s0R14iGYDAo3d3dUlNTIwCWZFCK6Bvn8vJycblchtaIFtOF5WLVMHPforV+NIQKw5n9Cicw42H8zVbHrBJpW05l2l/wkPkMDQ1N/jLn8OHDc34vmZOTM/lLnx/84Acx7iWRMRblvuEUnxwOBw4ePIivfe1rCx7AmQjMwcHBGPWOyFgMS9JFz1HonJwc5aOiRGbHf8OJiBQwLImIFDAsiYgUMCyJiBQwLImIFDAsiYgUMCyJiBQwLImIFDAsiYgUMCyJiBQwLImIFCzKb8ONuAdKtNo2c9+WAo5/4ki0bRnTsNQ0DU6n0/CLKzidTmiapmsdM/dtKeD4J45E3ZYxDUubzYaenh4EAgFD62iaBpvNpmsdM/dtKeD4Jw6923Linj1676cT620Z83/DbTabaV+sZu7bUsDxTxzhbEuHwxG7m4+FgQd4iIgUMCyJiBQwLImIFDAsiYgUMCyJiBQwLImIFDAsiYgUMCyJiBQwLImIFCzKhTTMyufz8ed2i8is46+3XxMXedBzsQe+LsyPYfkpn8+H/Px8DAwMGFrH6XSip6eHb4wZzDr+kfRLz4Uk+LowP4blpwKBAAYGBnT/mF+PiQsGBAIBvilmMOv4m7VfFHsMyxnM/mP+RGfW8Tdrvyh2eICHiEgBw5KISAHDkohIAcOSiEgBw5KISAHDkohIAcOSiEgBw5KISAHDkohIAcOSiEgBwzLBDQ4OYv/+/QgGg0rLHzt2DJcuXTK4V0Txh2GZ4Hw+HxobG1FSUrJgYDY1NeF73/sevF5vjHpHFD8Yljr4fD7ceeedePnllyfnBYNBPP7441i3bp0pQyY7Oxtnz57FmTNn5g3MpqYm7Nq1C6dPn8bDDz8c416qaWlpQXp6+qzJYrEgKSkJFy5cWJR++f1+5ObmYv/+/dPm9/X1IT8/H1VVVYvSL4oyIRER8Xg8AkA8Hs+8y9XV1UleXp74/X4REXn66aflnnvukZs3b0athhHru91uueuuu+Spp56S8fHxaY81NjZKenq6dHd3x7xfkbZx7tw5cTgcUlZWZkgN1XWOHDkimZmZMjw8LCIig4ODUlBQILt37zakX3oEg0Fpb2+XJ554QkpKSuT11183pE64jH7+0cKw/JTqBvP7/ZKXlyf19fWyb98+ycnJkd7e3qjWMGr9UIEZaVBGo1/httHZ2SlpaWlSVVVlWA3VdUZHR2X16tVSU1MjXq9XCgsLZdu2bRIMBg3pl6pgMCjf/e53xWq1CgBJTk4Wi8UiP//5z6NeK1wMyzijZ4M1NDSI3W6XzMxMeffddw2pYcT6ItMDs6GhIeKgjFa/9LbR1tYmVqtVamtrDauhd52jR49KVlaWbNiwQYqLi2VsbMywfql6/fXXxWKxCIBpU2pqqly/fj3q9cIRL2GpfPFfPfcTiUd6n9/IyAhKS0tx7733Gl5r5nqRbAuHw4HTp0/jS1/6EpqamnDy5Encf//9EbUZjX7pWffYsWPYsWMHDh06hO3btxtaS8+yW7ZsQWVlJXw+Hzo6OpCSkmJYv1S1t7eHnK9pGv7whz+guLg46jX1isbrJxLKF3VWTVXM+GRK1GmhT7eTJ09Kenq6PPPMM7JixQoZGRlR/mSa+ATlFP7419fXi6Zp0traqjzu0Rh/1b2elStXSn19fcz6xSnySZXynqXH41FdNC5N3AdlPl1dXdi6dStaW1uxceNGdHV1oa6uDnv27NFVK9z7uUz0MZL7wTQ3N+OFF15AY2MjNm/ejLy8PBQVFeHgwYNITg7v5Iho9Etl/A8cOICKigq0tbVh06ZNYdUB9I2/Sr8m9PX1ob+/Hy6Xy/B+qRocHERBQQH8fv/kvOTkZGRlZeGdd97RvfdrhGi8fmJC10dgAlvoe5M33nhDMjIypLm5eXJeS0uLZGZmitfrjUoNo9efejBnoq2rV6/OeZQ8Vv1SaWPv3r1it9ulq6vLsBqRrnPq1CnRNG3yTAkj+6XHn//8Z7njjjsmv7tcvXq1XL161ZBa4YiX7ywZlp+ab4NduXJFli9fLnV1ddPmj4+Py3333SfV1dUR1zB6/ZlHvae2Nd9pRUb3S6WNixcvCvD/gxJ2u33WtHnzZsP6qWed8vJycblcym1H0i+9RkdHpbu7WwDIxx9/bFidcDAs40wsNthihWWo04NmthVJYC7meZZG1zBrv8xcRy+z9msm/oInwb311luTv8wpKiqac7mpv/Q5fPhw7DpIFCd43/AEt3btWvztb39DXl7egstmZ2fjr3/9K5YvXx6DnhHFF4blEqASlBOcTqeBPSGKX/w3nIhIAcOSiEgBw5KISAHDkohIAcOSiEgBw5KISAHDkohIAcOSiEgBw5KISAHDkohIAX/uOIORl7ZP9FtzRINZx9+s/aLYYVh+StM0OJ1O5atih8vpdELTNENrxCOzjr9Z+0Wxx7D8lM1mQ09PDwKBgKF1NE2DzWYztEY8Muv4m7VfFHsMyylsNhtfsIvIrONv1n5RbPEADxGRAoYlEZEChiURkQKGJRGRAoYlEZEChiURkQKGJRGRAoYlEZEChiURkQKGJRGRAv7ckUzD5/PxN9g66B2viasb6bnKUSKNV6QYlmQKPp8P+fn5GBgYMLSO0+lET09P3AdAJOOl5wpKiTJe0cCwJFMIBAIYGBiA2+2Gw+EwpMbQ0BBycnIQCATi/s3P8Yo9hiWZisPhMOzNn4g4XrHDAzxERAoYlkREChiWREQKGJZERAoYlkREChiWREQKGJZERAoYlkRECnhSehw4f/48Tp48iWvXrgEA9u/fj+3bt+Nzn/vcIveMaOngnqVJiQiOHz8Ol8uFL3/5y7h+/TruuOMOAMDbb7+NNWvW4JFHHkFXV9ci95RoaWBYmlAwGMT3v/99PP/883jyySfR39+PpqYmPPfccwCAI0eOoLe3F0VFRSguLkZtbe2cbb3//vv41re+heHh4QXrighKS0tx6tSpkI97vV58/etfR09Pj9LzaGpqQmVlpdKyRGbHsDShsrIydHZ24s0330RJSQkyMjJmLZOVlYXy8nKcOXMGL774IhobG0O2lZ2djaGhIWzcuHHewBQRPPvss2hra8MXvvCFkMukp6cjPz8fRUVFCwZmU1MTdu3ahYcffnje5YjihpCpXLp0Sex2u/z973+f9Zjb7RYA4na7p83v6uoSm80mH330Ucg2R0ZG5Ctf+Yo89NBD4vV6RUTE4/EIAPF4PBIMBmXXrl2Sm5sr//rXv+btX6hlp7YlItLY2Cjp6enS3d2t/LxnthHKiRMnxG63z5pSU1MFgJw/fz7iGvFC5bn4fD7JycmR6urqafOvXbsmq1atkp/85CcR14iGeNkuDEuT2bFjh+zcuTPkY3OFpYjIQw89JC+99NKc7c4MzIkX6Mcff6wclBNmBubUF3s4QSkS/hvm3Llz4nA4pKyszLAaZqT6XI4cOSKZmZkyPDwsIiKDg4NSUFAgu3fvjlqNSLS3t8sXv/hFASBbt26Vnp4ew2pFimFpIrdu3ZLbbrtNLl++HPLx+cLyxIkT8tnPflbGx8fnbH9qYPb19QkAKSkp0RWUE6YG5ltvvSUA5De/+U1YQSkS3huzs7NT0tLSpKqqyrAaZqX6XEZHR2X16tVSU1MjXq9XCgsLZdu2bRIMBqNWI1wNDQ2iaZoAEACSmpoqn/nMZ0K+vs2AYWkiZ8+eldzc3Dkfny8sh4eHBYDcuHFj3hoTgfnAAw8IAMnJydEdlBMmAjMnJ0cAhB2UIvrfmG1tbWK1WqW2ttawGmam57kcPXpUsrKyZMOGDVJcXCxjY2NRr6HX6Oio3H777ZNBOTFpmqa017sYlM+z1HPfDgrPwMAAHA7HnGPt9Xon/4ZaxmKx4Nq1a7BarfPWeeWVV7Bu3ToA/z8Qc/vtt4e9fX/84x/j0qVLcLvd+OlPf4r7778/rLb0rHPs2DHs2LEDhw4dwvbt2w2tZVZ6nsOWLVtQWVkJn8+Hjo4OpKSkGFZL1YcffoiPPvpo1vxAIIC//OUvMd1GyhdPVk1VzPgE4MTJiGmhvZj6+nrRNE1aW1t17xlM7Ckl0qS617dy5Uqpr69f8uMValKlvGfp8XhUF6Uw9ff34/Of/zwuX74c8qZSHo8Hubm56O3txbJly6Y91t3djSeffBLvvfceLBZLyPZFBGVlZXjttddw+vRppKWlYefOnfD7/fjd736H9PR0Xf1tbm7GCy+8gJaWFqxduxbV1dXo6OhAe3s7Vq1apautifu9zOfAgQOoqKhAW1sbNm3apKv9qYy8b02sqIzXhL6+PvT398PlcoVVy6jx+tGPfoTDhw/D7/dPzrNYLOju7saaNWuiXi9iuj5qyHDf+MY3ZN++fSEfm+87pMcee2zeI8JznR4U6rQiFaGOeus5BWmmhb4f27t3r9jtdunq6tLVrp4a8UTPczl16pRomiZ+v9+wGuEYGxuTiooKycjIEABSUFAQ0fY1GsPSZP74xz9KVlaW3Lp1a9Zjc71433vvPbFYLHOedrFQiOkNzPlODwo3MOd7Y168eFGA/x8tDXWe5ebNmyOuEW/0PJfy8nJxuVyG1ohEMBiUQCBgaI1oYFiazPj4uDz66KOyfv16GRkZmfZYqBfvhx9+KHfffbeUlpaGbE81vFQDU+U8ynACMxZvzKUalmauEU/4c0eTSU5ORmtrK8bHx7F+/XqcP38eIjJruWAwiM7OTjzwwAN48MEHUVNTE7K9t99+Gx0dHTh79izy8/PnrJuWlobf//73sNlsaGlpCbnM0NAQqqqqcPr0aRQVFc3ZVlJSEg4ePIhvfvOb+NnPfjb/EyaKE0kS6p1Ii87v9+OHP/whGhoacPfdd+OJJ55AZmYmvv3tb6OiogLNzc0YHh7Gc889h+effx5JSUlzthUIBKBpmlLdQCAAi8UyZ3t62hIRjI2NzXnAaaqhoSEsW7YMHo/HsIMvsagRKxyv2OP1LE3KarXiF7/4BSorK3H8+HG0tbXh+vXrAIA333wT1dXVKC4uVgou1XBTWVZPW0lJSUpBSRQPGJYml5GRgZKSEpSUlEBE4PV6kZGRMe+eJBFFH8MyjiQlJfHfIaJFwgM8REQKGJZERAoYlkREChiWREQKGJZERAoYlkREChiWREQKGJZERAp4UjqZipG3E0iE20nMxPGKHYYlmYKmaXA6ncpX/w6X0+nU9ft2s+J4xR6vOkSm4fP5EAgEDK2haRpsNpuhNWKF4xVbDEsiIgU8wENEpIBhSUSkgGFJRKSAYUlEpIBhSUSkgGFJRKSAYUlEpIBhSUSkgGFJRKSAYUlEpIBhSUSkgGFJRKSAYUlEpIBhSUSk4H8CfWZYUfzzLwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cir.h(0) # Add Hadamard gate to qubit 0\n", + "cir.x([0, 1]) # Add X gate to qubit 0 and 1\n", + "cir.cx([0, 2]) # Add CNOT gate to qubit 0 and 2\n", + "cir.swap([[1, 2], [0, 2]]) # Add SWAP gate to qubit 1 and 2, and qubit 0 and 2\n", + "cir.z() # Add Z gate to all qubits\n", + "cir.cy() # Add CY gate in cycle\n", + "cir.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When the number of qubits is not specified, the total number of qubits will be changed as operations are added to the circuit. However, in this case, one cannot add the first operation without specifying the location." + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "print(cir.num_qubits)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For parametrized gates, `Circuit` can add the gate with randomly generated parameters, or you can specify them as keyword arguments." + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cir.rx() # Add Rx gate to all qubits with random parameters\n", + "cir.rx([0, 1], param=np.arange(2)) # Add RX gate to the first two qubits with specified parameters\n", + "\n", + "cir.u3([0]) # Add universal single qubit gate\n", + "cir.universal_two_qubits([0, 1]) # Add universal two qubits gate\n", + "cir.universal_three_qubits([0, 1, 2]) # Add universal three qubits gate\n", + "cir.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also add custom gates by specifying the matrix representation of the gate." + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cir.oracle(dagger(qft_matrix(3)), qubits_idx=[0, 1, 2], latex_name=r'$\\text{QFT}^\\dagger$')\n", + "cir.control_oracle(random_unitary(2), qubits_idx=[0, 1, 2], gate_name='O')\n", + "cir.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similar construction semantic applies to noisy operations such as depolarizing channel, where the related plot logic is not supported yet." + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [], + "source": [ + "cir.depolarizing(0.1) # Add depolarizing noise with probability 0.1\n", + "cir.bit_phase_flip(0.2) # Add bit-phase flip noise with probability 0.2\n", + "\n", + "sigma = random_state(3)\n", + "cir.choi_channel(replacement_choi(sigma), qubits_idx=[0, 1, 2]) # Add replacement channel\n", + "cir.kraus_channel(reset_kraus([0.1, 0.2]), qubits_idx=[1, 2]) # Add reset channel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "More available operations can be found in the [API document](www.quairkit.com)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Add circuit templates\n", + "\n", + "If you find it hard to construct the training circuit from scratch, you can use the predefined circuit templates in QuAIRKit. Note that the templates are only available for the circuits with a known number of qubits." + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cir = Circuit(num_qubits)\n", + "\n", + "cir.linear_entangled_layer(depth=1)\n", + "\n", + "cir.real_block_layer(depth=1)\n", + "cir.real_entangled_layer(depth=1)\n", + "\n", + "cir.complex_block_layer(depth=1)\n", + "cir.complex_entangled_layer(depth=1)\n", + "\n", + "cir.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Operator management\n", + "\n", + "`Circuit` is essentially a list of `Operator` objects. Thus, you can access the operations by indexing the `Circuit` object." + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The matrix of the gate at the 5th position is\n", + " tensor([[[-0.9971+0.j, -0.0765+0.j],\n", + " [ 0.0765+0.j, -0.9971+0.j]],\n", + "\n", + " [[-0.9955+0.j, -0.0943+0.j],\n", + " [ 0.0943+0.j, -0.9955+0.j]]], grad_fn=)\n" + ] + } + ], + "source": [ + "print('The matrix of the gate at the 5th position is\\n', cir[4].matrix)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also add or remove the operations for advanced setup." + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The quantum circuit after adding gates is: \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The quantum circuit after removing gates is:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cir = Circuit(3)\n", + "\n", + "# Set parameters and customize quantum gates. Here we select Ry, Rx, Rz gates\n", + "param = np.random.rand(2)\n", + "\n", + " # By default, randomly generates a set of parameters\n", + "rz_gate = RZ(param=param, qubits_idx=[1, 2])\n", + "\n", + "# Add quantum gates\n", + "cir.ry([0, 2])\n", + "cir.rx([0, 1])\n", + "cir.insert(index=2, module=rz_gate) # index where to insert\n", + "\n", + "print('The quantum circuit after adding gates is: ')\n", + "cir.plot()\n", + "\n", + "cir.pop(1) # Remove Rx gate\n", + "print('The quantum circuit after removing gates is:')\n", + "cir.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Execution\n", + "\n", + "The `Circuit` object can be executed by calling the object itself." + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The output state for inputting zero state is: \n", + "---------------------------------------------------\n", + " Backend: state_vector\n", + " System dimension: [2, 2, 2]\n", + " System sequence: [2, 1, 0]\n", + "[-0.29+0.26j -0.05+0.05j 0. +0.j 0. +0.j 0.88-0.21j 0.16-0.04j\n", + " 0. +0.j 0. +0.j ]\n", + "---------------------------------------------------\n", + "\n", + "The output state for inputting sigma is: \n", + "---------------------------------------------------\n", + " Backend: density_matrix\n", + " System dimension: [2, 2, 2]\n", + " System sequence: [2, 1, 0]\n", + "[[ 0.09-0.j 0.06+0.03j -0.02-0.04j -0.01-0.03j 0.02+0.04j 0.07+0.11j\n", + " -0.01+0.05j 0.12+0.05j]\n", + " [ 0.06-0.03j 0.06+0.j -0.04+0.01j -0.02-0.04j 0.05+0.03j 0.07+0.04j\n", + " 0.02+0.04j 0.1 -0.j ]\n", + " [-0.02+0.04j -0.04-0.01j 0.16+0.j -0.06+0.06j -0.03-0.12j -0.05+0.07j\n", + " -0.04-0.09j -0.04-0.j ]\n", + " [-0.01+0.03j -0.02+0.04j -0.06-0.06j 0.08-0.j -0.06+0.08j -0.02-0.03j\n", + " -0.04+0.04j -0.05+0.06j]\n", + " [ 0.02-0.04j 0.05-0.03j -0.03+0.12j -0.06-0.08j 0.13-0.j -0.01+0.01j\n", + " 0.08-0.j 0.08-0.03j]\n", + " [ 0.07-0.11j 0.07-0.04j -0.05-0.07j -0.02+0.03j -0.01-0.01j 0.23+0.j\n", + " 0. +0.06j 0.13-0.11j]\n", + " [-0.01-0.05j 0.02-0.04j -0.04+0.09j -0.04-0.04j 0.08+0.j 0. -0.06j\n", + " 0.07-0.j 0.03-0.06j]\n", + " [ 0.12-0.05j 0.1 +0.j -0.04+0.j -0.05-0.06j 0.08+0.03j 0.13+0.11j\n", + " 0.03+0.06j 0.19+0.j ]]\n", + "---------------------------------------------------\n", + "\n" + ] + } + ], + "source": [ + "output_state = cir() # Run the circuit with initial state |0>\n", + "print('The output state for inputting zero state is:', output_state)\n", + "\n", + "output_state = cir(sigma) # Run the circuit with initial state sigma\n", + "print('The output state for inputting sigma is:', output_state)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Other properties\n", + "\n", + "Circuit have other properties for further information and manipulation." + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The circuit depth is 2\n", + "The unitary matrix of this circuit is\n", + " tensor([[-0.2855+0.2624j, -0.6660+0.6122j, 0.0000+0.0000j, 0.0000+0.0000j,\n", + " 0.0513-0.0472j, 0.1197-0.1100j, 0.0000+0.0000j, 0.0000+0.0000j],\n", + " [ 0.8807-0.2067j, -0.3775+0.0886j, 0.0000+0.0000j, 0.0000+0.0000j,\n", + " -0.1583+0.0372j, 0.0678-0.0159j, 0.0000+0.0000j, 0.0000+0.0000j],\n", + " [ 0.0000+0.0000j, 0.0000+0.0000j, -0.3775-0.0886j, -0.8807-0.2067j,\n", + " 0.0000+0.0000j, 0.0000+0.0000j, 0.0678+0.0159j, 0.1583+0.0372j],\n", + " [ 0.0000+0.0000j, 0.0000+0.0000j, 0.6660+0.6122j, -0.2855-0.2624j,\n", + " 0.0000+0.0000j, 0.0000+0.0000j, -0.1197-0.1100j, 0.0513+0.0472j],\n", + " [-0.0513+0.0472j, -0.1197+0.1100j, 0.0000+0.0000j, 0.0000+0.0000j,\n", + " -0.2855+0.2624j, -0.6660+0.6122j, 0.0000+0.0000j, 0.0000+0.0000j],\n", + " [ 0.1583-0.0372j, -0.0678+0.0159j, 0.0000+0.0000j, 0.0000+0.0000j,\n", + " 0.8807-0.2067j, -0.3775+0.0886j, 0.0000+0.0000j, 0.0000+0.0000j],\n", + " [ 0.0000+0.0000j, 0.0000+0.0000j, -0.0678-0.0159j, -0.1583-0.0372j,\n", + " 0.0000+0.0000j, 0.0000+0.0000j, -0.3775-0.0886j, -0.8807-0.2067j],\n", + " [ 0.0000+0.0000j, 0.0000+0.0000j, 0.1197+0.1100j, -0.0513-0.0472j,\n", + " 0.0000+0.0000j, 0.0000+0.0000j, 0.6660+0.6122j, -0.2855-0.2624j]],\n", + " grad_fn=)\n" + ] + } + ], + "source": [ + "print('The circuit depth is', cir.depth)\n", + "print('The unitary matrix of this circuit is\\n', cir.unitary_matrix())" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The trainable parameters of entire circuit is tensor([0.3557, 3.9515])\n", + "The trainable parameters of entire circuit is tensor([1., 1.])\n" + ] + } + ], + "source": [ + "print('The trainable parameters of entire circuit is', cir.param)\n", + "cir.update_param(torch.ones_like(cir.param)) # Update the parameters of the circuit\n", + "print('The trainable parameters of entire circuit is', cir.param)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is worth noting that `Circuit` is inherently a subclass of `torch.Module`, which means that it can be used as a part of the neural network model in PyTorch." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training noisy ground state preparation\n", + "\n", + "In this demo, we will prepare the ground state of a randomly generated Hamiltonian. In particular, we suppose the output state contains a depolarizing channel with error parameter 0.1. The loss function is defined as the expectation value of the circuit with respect to the Hamiltonian." + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [], + "source": [ + "hamiltonian = random_hamiltonian_generator(num_qubits)\n", + "\n", + "# construct QNN\n", + "cir = Circuit(num_qubits)\n", + "cir.complex_entangled_layer(depth=20)\n", + "cir.depolarizing(0.1)\n", + "\n", + "# define loss function\n", + "loss_fcn = lambda circuit: circuit().expec_val(hamiltonian)\n", + "\n", + "# set optimizer\n", + "LR, NUM_ITR = 0.1, 200\n", + "opt = torch.optim.Adam(lr=LR, params=cir.parameters())\n", + "scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(opt, 'min', factor=0.5) # activate scheduler" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 0, loss: -0.14351884, avg_time: 0.0351s\n", + "iter: 20, loss: -1.08153820, avg_time: 0.0249s\n", + "iter: 40, loss: -1.15248334, avg_time: 0.0225s\n", + "iter: 60, loss: -1.15756059, avg_time: 0.0252s\n", + "iter: 80, loss: -1.15914619, avg_time: 0.0228s\n", + "iter: 100, loss: -1.15918970, avg_time: 0.0234s\n", + "iter: 120, loss: -1.15919995, avg_time: 0.0230s\n", + "iter: 140, loss: -1.15920043, avg_time: 0.0223s\n", + "iter: 160, loss: -1.15920222, avg_time: 0.0230s\n", + "iter: 180, loss: -1.15873241, avg_time: 0.0230s\n", + "iter: 199, loss: -1.14867520, avg_time: 0.0213s\n" + ] + } + ], + "source": [ + "loss_list, time_list = [], []\n", + "\n", + "for itr in range(NUM_ITR):\n", + " start_time = time.time()\n", + " opt.zero_grad()\n", + "\n", + " loss = loss_fcn(cir) # compute loss\n", + "\n", + " loss.backward()\n", + " opt.step()\n", + " scheduler.step(loss)\n", + "\n", + " loss = loss.item()\n", + " loss_list.append(loss)\n", + " time_list.append(time.time() - start_time)\n", + "\n", + " if itr % 20 == 0 or itr == NUM_ITR - 1:\n", + " print(f\"iter: {itr}, loss: {loss:.8f}, avg_time: {np.mean(time_list):.4f}s\")\n", + " time_list = []" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "quair", + "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.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}