en/source/intro/4.1_python_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum states"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate quantum states"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate $n$ qubit quantum states using `QuantumState` class and initialize it as $\\left|0\\right>^{\\otimes n}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qulacs import QuantumState\n",
    "# Generate 5 qubit states\n",
    "n = 5\n",
    "state = QuantumState(n)\n",
    "# Initialize as |00000>\n",
    "state.set_zero_state()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can not generate the quantum states if the memory is not sufficient.\n",
    "\n",
    "With the memory of a typical laptop or desktop computer, the limit of qubits you can create is about 26, 27 qubits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Obtain data of quantum state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The quantum state is expressed as an array of length $2^n$. Note that if the quantum state is formed by GPU, and if the $n$ is large, it can become an extremely heavy operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+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 0.+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 0.+0.j 0.+0.j 0.+0.j 0.+0.j\n",
      " 0.+0.j 0.+0.j]\n"
     ]
    }
   ],
   "source": [
    "from qulacs import QuantumState\n",
    "n = 5\n",
    "state = QuantumState(n)\n",
    "state.set_zero_state()\n",
    "# Obtain state vector as numpy array\n",
    "data = state.get_vector()\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialize quantum states"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The generated quantum state can be initialized to a computational basis using the `set_computational_basis` or to a random state using the `set_Harr_random_state`.\n",
    "\n",
    "Note that in Qulacs, the subscripts of the qubits start from 0, and the rightmost bit is the 0-th qubit when written as $\\ket{0000}$ (In other libraries and textbooks, the leftmost bit may be the 0-th qubit)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[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 0.+0.j\n",
      " 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+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 0.+0.j 0.+0.j 0.+0.j 0.+0.j\n",
      " 0.+0.j 0.+0.j]\n",
      "[ 0.15288771+0.09518259j -0.09425367+0.03861159j -0.05536341+0.00789662j\n",
      "  0.0940157 -0.05557305j  0.1545892 -0.07198446j -0.03716513+0.02058911j\n",
      "  0.03705915+0.14986423j  0.11286983-0.0532145j   0.26156705-0.00567617j\n",
      " -0.21049203+0.02588394j  0.03015688-0.13549472j -0.03223217-0.04269361j\n",
      "  0.08834552-0.03187188j  0.02230196-0.1931069j   0.23539418-0.04396539j\n",
      "  0.08287765+0.03878752j -0.23154572+0.21837285j  0.12294496+0.04516656j\n",
      " -0.06663951-0.02234198j -0.02088798-0.19753772j  0.15883044+0.1338028j\n",
      "  0.10159162-0.07612246j -0.07501653+0.06349231j  0.23882471-0.03687719j\n",
      " -0.027509  -0.0642422j  -0.04664696+0.17370059j  0.24072434-0.02911506j\n",
      "  0.14005551-0.03788459j  0.0301706 +0.0869898j  -0.0594587 -0.38821123j\n",
      "  0.07373735-0.18018923j -0.04819191+0.11740737j]\n",
      "[ 0.09232558+0.06460115j  0.14544754-0.10413526j  0.11300793-0.02455806j\n",
      "  0.00811251+0.2426378j  -0.01116588+0.23770313j -0.10691448+0.0487731j\n",
      " -0.01654446+0.17073103j  0.22250403+0.01934699j  0.04728154+0.22585226j\n",
      "  0.04475383+0.20375993j -0.10592159+0.10428549j -0.10175932-0.04016904j\n",
      "  0.04241271+0.08723859j  0.18205362+0.06190871j  0.14103367-0.12925877j\n",
      " -0.08269267+0.08879486j -0.14479848-0.0183179j  -0.32601567+0.06762062j\n",
      "  0.03482754+0.04464901j  0.09181499+0.05497985j  0.06870746+0.12628442j\n",
      " -0.00624006-0.21793139j -0.11181371+0.2659879j  -0.04589826+0.00891387j\n",
      " -0.04058365+0.30265587j -0.13894575-0.04392724j -0.03499327+0.0184768j\n",
      "  0.05033425-0.07376874j  0.07124237+0.15451312j  0.09319498+0.08341551j\n",
      " -0.03002195-0.14677347j -0.05309219+0.10184815j]\n"
     ]
    }
   ],
   "source": [
    "from qulacs import QuantumState\n",
    "n = 5\n",
    "state = QuantumState(n)\n",
    "state.set_zero_state()\n",
    "# Initialize as |00101>\n",
    "state.set_computational_basis(0b00101)\n",
    "print(state.get_vector())\n",
    "# Generate random initial state\n",
    "state.set_Haar_random_state()\n",
    "print(state.get_vector())\n",
    "# Generate random initial state with specifying seed\n",
    "seed = 0\n",
    "state.set_Haar_random_state(seed)\n",
    "print(state.get_vector())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copy and load quantum state data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The quantum state can be copied and loaded from other quantum state data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[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 0.+0.j\n",
      " 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+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 0.+0.j 0.+0.j 0.+0.j 0.+0.j\n",
      " 0.+0.j 0.+0.j]\n",
      "[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 0.+0.j\n",
      " 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+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 0.+0.j 0.+0.j 0.+0.j 0.+0.j\n",
      " 0.+0.j 0.+0.j]\n"
     ]
    }
   ],
   "source": [
    "from qulacs import QuantumState\n",
    "n = 5\n",
    "state = QuantumState(n)\n",
    "state.set_computational_basis(0b00101)\n",
    "# Copy to generate another quantum state\n",
    "second_state = state.copy()\n",
    "print(second_state.get_vector())\n",
    "# Generate a new quantum state, and copy from an existing quantum state\n",
    "third_state = QuantumState(n)\n",
    "third_state.load(state)\n",
    "print(third_state.get_vector())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operate classic registers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Quantum state can be read and written as a classic register."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "from qulacs import QuantumState\n",
    "n = 5\n",
    "state = QuantumState(n)\n",
    "state.set_zero_state()\n",
    "# Set the 3rd classical register as 1\n",
    "register_position = 3\n",
    "register_value = 1\n",
    "state.set_classical_value(register_position, register_value)\n",
    "# Obtain the value of the 3rd classical register\n",
    "obtained_value = state.get_classical_value(register_position)\n",
    "print(obtained_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate quantum states"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Various calculations can be applied to the quantum state.\n",
    "The operations do not change the quantum state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "squred norm :  1.0000000000000002\n",
      "entropy :  3.1179008329119045\n",
      "prob_meas_3rd :  0.5633787619052777\n",
      "marginal_prob :  0.0347875492304793\n"
     ]
    }
   ],
   "source": [
    "from qulacs import QuantumState\n",
    "n = 5\n",
    "state = QuantumState(n)\n",
    "state.set_Haar_random_state()\n",
    "# Calculate norm\n",
    "norm = state.get_squared_norm()\n",
    "print(\"squared norm : \",norm)\n",
    "# Calculate the entropy when measured in z-basis\n",
    "entropy = state.get_entropy() \n",
    "print(\"entropy : \",entropy)\n",
    "# Calculate the probability that the index-th qubit is 0 when measured in z-basis\n",
    "index = 3\n",
    "zero_probability = state.get_zero_probability(index)\n",
    "print(\"prob_meas_3rd : \",zero_probability)\n",
    "# Calculate marginal probabilities\n",
    "# (Here is an example of the probability that 0,3-th qubit is measured as 0 and 1,2-th qubit is measured as 1)\n",
    "value_list = [0,1,1,0,2]\n",
    "marginal_probability = state.get_marginal_probability(value_list)\n",
    "print(\"marginal_prob : \",marginal_probability)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate the inner product of quantum states"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The inner product of quantum states can be calculated by the `inner_product` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0.009659627924345642+0.0037543729576012927j)\n"
     ]
    }
   ],
   "source": [
    "from qulacs import QuantumState\n",
    "from qulacs.state import inner_product\n",
    "n = 5\n",
    "state_bra = QuantumState(n)\n",
    "state_ket = QuantumState(n)\n",
    "state_bra.set_Haar_random_state()\n",
    "state_ket.set_computational_basis(0)\n",
    "# Calculate the inner product\n",
    "value = inner_product(state_bra, state_ket)\n",
    "print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Release quantum states"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`del` can be used to force the release of quantum states from memory.\n",
    "\n",
    "You do not need to use `del` to release a quantum state that is no longer in use. However, it is useful when memory capacity is insufficient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qulacs import QuantumState\n",
    "n = 5\n",
    "state = QuantumState(n)\n",
    "# Release quantum state\n",
    "del state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Obtain detailed information about quantum states"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can display information about quantum states by directly `print` an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " *** Quantum State ***\n",
      " * Qubit Count : 5\n",
      " * Dimension   : 32\n",
      " * State vector : \n",
      "(1,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "(0,0)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from qulacs import QuantumState\n",
    "n = 5\n",
    "state = QuantumState(n)\n",
    "print(state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum gate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate and operate quantum gates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quantum gates implemented by default are defined in the `gate` module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      "[0.+0.j 0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      "[0.38268343+0.j 0.        +0.j 0.92387953+0.j 0.        +0.j\n",
      " 0.        +0.j 0.        +0.j 0.        +0.j 0.        +0.j]\n",
      "[0.        +0.j 0.        +0.j 0.        +0.j 0.        +0.j\n",
      " 0.38268343+0.j 0.        +0.j 0.92387953+0.j 0.        +0.j]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from qulacs import QuantumState\n",
    "from qulacs.gate import X, RY, DenseMatrix\n",
    "n = 3\n",
    "state = QuantumState(n)\n",
    "state.set_zero_state()\n",
    "print(state.get_vector())\n",
    "# Operate X on 1st-qubit\n",
    "index = 1\n",
    "x_gate = X(index)\n",
    "x_gate.update_quantum_state(state)\n",
    "print(state.get_vector())\n",
    "# Rotate 1st-qubit by Y Pauli with pi/4.0\n",
    "angle = np.pi / 4.0\n",
    "ry_gate = RY(index, angle)\n",
    "ry_gate.update_quantum_state(state)\n",
    "print(state.get_vector())\n",
    "# Apply quantum gate created by gate matrix to 2nd-qubit\n",
    "dense_gate = DenseMatrix(2, [[0,1],[1,0]])\n",
    "dense_gate.update_quantum_state(state)\n",
    "print(state.get_vector())\n",
    "# Release gate\n",
    "del x_gate\n",
    "del ry_gate\n",
    "del dense_gate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quantum gates implemented by default are as follows:\n",
    "\n",
    "- Single-qubit Pauli operation: `Identity`, `X`, `Y`, `Z`\n",
    "- Single-qubit Clifford operation: `H`, `S`, `Sdag`, `T`, `Tdag`, `sqrtX`, `sqrtXdag`, `sqrtY`, `sqrtYdag`\n",
    "- Two-qubit Clifford operation: `CNOT`, `CZ`, `SWAP`\n",
    "- Single-qubit Pauli rotation: `RX`, `RY`, `RZ`\n",
    "- General Pauli operation : `Pauli`, `PauliRotation`\n",
    "- IBMQ basis-gate: `U1`, `U2`, `U3`\n",
    "- General gate: `DenseMatrix`\n",
    "- Measurement: `Measurement`\n",
    "- Noise: `BitFlipNoise`, `DephasingNoise`, `IndepenedentXZNoise`, `DepolarizingNoise`\n",
    "\n",
    "Rotation gates `RX`, `RY`, and `RZ` operate as Pauli rotation $\\exp(i\\frac{\\theta}{2}P)$ based on corresponding Pauli operator $P$ and argument $\\theta$. Please check the API documents for details of each gate."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Merge quantum gates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A new single quantum gate can be generated by merging the quantum gates that continue to operate in sequence.\n",
    "By doing so, we can reduce access to quantum states."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.38268343+0.j 0.        +0.j 0.92387953+0.j 0.        +0.j\n",
      " 0.        +0.j 0.        +0.j 0.        +0.j 0.        +0.j]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from qulacs import QuantumState\n",
    "from qulacs.gate import X, RY, merge\n",
    "n = 3\n",
    "state = QuantumState(n)\n",
    "state.set_zero_state()\n",
    "index = 1\n",
    "x_gate = X(index)\n",
    "angle = np.pi / 4.0\n",
    "ry_gate = RY(index, angle)\n",
    "# Create the new gate by merging gates\n",
    "# First argument applies first\n",
    "x_and_ry_gate = merge(x_gate, ry_gate)\n",
    "x_and_ry_gate.update_quantum_state(state)\n",
    "print(state.get_vector())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sum of quantum gate matrices\n",
    "\n",
    "A new gate can be generated by summing gates. (Not available for gates with control-qubit, because that operation is undefined yet.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " *** gate info *** \n",
      " * gate name : DenseMatrix\n",
      " * target    : \n",
      " 0 : commute       \n",
      " 1 : commute       \n",
      " * control   : \n",
      " * Pauli     : no\n",
      " * Clifford  : no\n",
      " * Gaussian  : no\n",
      " * Parametric: no\n",
      " * Diagonal  : no\n",
      " * Matrix\n",
      "(1,0) (0,0) (0,0) (0,0)\n",
      "(0,0) (0,0) (0,0) (0,0)\n",
      "(0,0) (0,0) (0,0) (0,0)\n",
      "(0,0) (0,0) (0,0) (1,0)\n",
      "\n",
      " *** gate info *** \n",
      " * gate name : DenseMatrix\n",
      " * target    : \n",
      " 0 : commute       \n",
      " 1 : commute       \n",
      " * control   : \n",
      " * Pauli     : no\n",
      " * Clifford  : no\n",
      " * Gaussian  : no\n",
      " * Parametric: no\n",
      " * Diagonal  : no\n",
      " * Matrix\n",
      "(0.5,0)   (0,0)   (0,0) (0.5,0)\n",
      "  (0,0)   (0,0)   (0,0)   (0,0)\n",
      "  (0,0)   (0,0)   (0,0)   (0,0)\n",
      "(0.5,0)   (0,0)   (0,0) (0.5,0)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from qulacs import QuantumState\n",
    "from qulacs.gate import P0,P1,add, merge, Identity, X, Z\n",
    "gate00 = merge(P0(0),P0(1))\n",
    "gate11 = merge(P1(0),P1(1))\n",
    "# |00><00| + |11><11|\n",
    "proj_00_or_11 = add(gate00, gate11)\n",
    "print(proj_00_or_11)\n",
    "gate_ii_zz = add(Identity(0), merge(Z(0),Z(1)))\n",
    "gate_ii_xx = add(Identity(0), merge(X(0),X(1)))\n",
    "proj_00_plus_11 = merge(gate_ii_zz, gate_ii_xx)\n",
    "# ((|00>+|11>)(<00|+<11|))/2 = (II + ZZ)(II + XX)/4\n",
    "proj_00_plus_11.multiply_scalar(0.25)\n",
    "print(proj_00_plus_11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Special quantum gate and common quantum gate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Qulacs, the basic quantum gates are divided into the following two ways:\n",
    "\n",
    "- Special gate: There are dedicated speed-up functions for utilizing the special gate.\n",
    "- Common gate: The gate holds the gate matrix and operates by multiplying the matrix.\n",
    "\n",
    "The special gate is faster than the common gate because of the dedicated functions. But in a special gate, operations that change the function of a quantum gate, such as increasing the number of control qubits, cannot be performed later. This kind of change can be made only when the special gate is transformed into a common gate, which can be realized by `gate.to_matrix_gate`. \n",
    "\n",
    "Here's an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from qulacs import QuantumState\n",
    "from qulacs.gate import to_matrix_gate, X\n",
    "n = 3\n",
    "state = QuantumState(n)\n",
    "state.set_zero_state()\n",
    "index = 0\n",
    "x_gate = X(index)\n",
    "x_mat_gate = to_matrix_gate(x_gate)\n",
    "# Only operate when 1st-qubit is 0\n",
    "control_index = 1\n",
    "control_with_value = 0\n",
    "x_mat_gate.add_control_qubit(control_index, control_with_value)\n",
    "x_mat_gate.update_quantum_state(state)\n",
    "print(state.get_vector())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Obtain the gate matrix of the quantum gate\n",
    "\n",
    "The gate matrix of the generated quantum gate can be obtained, but gate matrices do not include the control qubit. Especially, note that gates without gate matrix (ex. $n$-qubit Pauli rotation gate) require a very long time and memory to obtain the matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.38268343+0.j  0.92387953+0.j]\n",
      " [ 0.92387953+0.j -0.38268343+0.j]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from qulacs import QuantumState\n",
    "from qulacs.gate import X, RY, merge\n",
    "n = 3\n",
    "state = QuantumState(n)\n",
    "state.set_zero_state()\n",
    "index = 1\n",
    "x_gate = X(index)\n",
    "angle = np.pi / 4.0\n",
    "ry_gate = RY(index, angle)\n",
    "x_and_ry_gate = merge(x_gate, ry_gate)\n",
    "# Obtain gate matrix\n",
    "matrix = x_and_ry_gate.get_matrix()\n",
    "print(matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Obtain information about quantum gate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can display information about a quantum gate by directly `print` an object.\n",
    "The gate matrix can only be displayed if the quantum gate has explicit matrix elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " *** gate info *** \n",
      " * gate name : X\n",
      " * target    : \n",
      " 0 : commute X     \n",
      " * control   : \n",
      " * Pauli     : yes\n",
      " * Clifford  : yes\n",
      " * Gaussian  : no\n",
      " * Parametric: no\n",
      " * Diagonal  : no\n",
      "\n",
      " *** gate info *** \n",
      " * gate name : DenseMatrix\n",
      " * target    : \n",
      " 0 : commute X     \n",
      " * control   : \n",
      " * Pauli     : no\n",
      " * Clifford  : no\n",
      " * Gaussian  : no\n",
      " * Parametric: no\n",
      " * Diagonal  : no\n",
      " * Matrix\n",
      "(0,0) (1,0)\n",
      "(1,0) (0,0)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from qulacs.gate import X, to_matrix_gate\n",
    "gate = X(0)\n",
    "print(gate)\n",
    "print(to_matrix_gate(gate))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implement of common quantum gate\n",
    "Qulacs implements various maps of quantum information in the following forms.\n",
    "\n",
    "#### Unitary operation\n",
    "\n",
    "Implemented as the quantum gate.\n",
    "\n",
    "#### Projection operator and Kraus operator, etc.\n",
    "\n",
    "Implemented as the quantum gate. In general, the norm of the quantum state is not preserved after the operation. \n",
    "\n",
    "The gate can be generated by `DenseMatrix`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " *** gate info *** \n",
      " * gate name : DenseMatrix\n",
      " * target    : \n",
      " 0 : commute       \n",
      " * control   : \n",
      " * Pauli     : no\n",
      " * Clifford  : no\n",
      " * Gaussian  : no\n",
      " * Parametric: no\n",
      " * Diagonal  : no\n",
      " * Matrix\n",
      "(0,0) (1,0)\n",
      "(1,0) (0,0)\n",
      "\n",
      " *** gate info *** \n",
      " * gate name : DenseMatrix\n",
      " * target    : \n",
      " 0 : commute       \n",
      " 1 : commute       \n",
      " * control   : \n",
      " * Pauli     : no\n",
      " * Clifford  : no\n",
      " * Gaussian  : no\n",
      " * Parametric: no\n",
      " * Diagonal  : no\n",
      " * Matrix\n",
      "(1,0) (0,0) (0,0) (0,0)\n",
      "(0,0) (1,0) (0,0) (0,0)\n",
      "(0,0) (0,0) (0,0) (1,0)\n",
      "(0,0) (0,0) (1,0) (0,0)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from qulacs.gate import DenseMatrix\n",
    "# 1-qubit gate\n",
    "gate = DenseMatrix(0, [[0,1],[1,0]])\n",
    "print(gate)\n",
    "# 2-qubit gate\n",
    "gate = DenseMatrix([0,1], [[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]])\n",
    "print(gate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Probabilistic unitary operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given multiple unitary operations and probability distributions, probabilistic unitary operations can be created by `Probabilistic` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qulacs.gate import Probabilistic, X, Y\n",
    "distribution = [0.1, 0.2, 0.3]\n",
    "gate_list = [X(0), Y(0), X(1)]\n",
    "gate = Probabilistic(distribution, gate_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the sum of the probabilities is less than 1, the remaining probabilities functionalize as Identity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CPTP-map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CPTP-map can be created by giving the `CPTP` function a list of Kraus operators satisfying completeness."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qulacs.gate import merge,CPTP, P0,P1\n",
    "gate00 = merge(P0(0),P0(1))\n",
    "gate01 = merge(P0(0),P1(1))\n",
    "gate10 = merge(P1(0),P0(1))\n",
    "gate11 = merge(P1(0),P1(1))\n",
    "gate_list = [gate00, gate01, gate10, gate11]\n",
    "gate = CPTP(gate_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### POVM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since it is the same as Instrument in numerical calculation, it is realized as Instrument."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Instrument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to the general CPTP-map operation, `Instrument` is an operation that obtains the array subscripts of the randomly acting Kraus operator.\n",
    "For example, a measurement on the Z basis is to operate on the CPTP-map consisting of `P0` and `P1` and know which one was operated.\n",
    "In Qulacs, this is achieved by specifying the information of the CPTP-map and the address of the classic register in which the subscripts of the operated Kraus operator are written in the `Instrument` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " *** Quantum State ***\n",
      " * Qubit Count : 2\n",
      " * Dimension   : 4\n",
      " * State vector : \n",
      "(0.0384086,-0.443594)\n",
      "  (0.153984,0.292821)\n",
      "(-0.386978,0.0323475)\n",
      "  (0.690361,0.254749)\n",
      "\n",
      " *** Quantum State ***\n",
      " * Qubit Count : 2\n",
      " * Dimension   : 4\n",
      " * State vector : \n",
      "              (0,0)\n",
      "              (0,0)\n",
      "              (0,0)\n",
      "(0.938164,0.346191)\n",
      "\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "from qulacs import QuantumState\n",
    "from qulacs.gate import merge,Instrument, P0,P1\n",
    "gate00 = merge(P0(0),P0(1))\n",
    "gate01 = merge(P0(0),P1(1))\n",
    "gate10 = merge(P1(0),P0(1))\n",
    "gate11 = merge(P1(0),P1(1))\n",
    "gate_list = [gate00, gate01, gate10, gate11]\n",
    "classical_pos = 0\n",
    "gate = Instrument(gate_list, classical_pos)\n",
    "state = QuantumState(2)\n",
    "state.set_Haar_random_state()\n",
    "print(state)\n",
    "gate.update_quantum_state(state)\n",
    "result = state.get_classical_value(classical_pos)\n",
    "print(state)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Adaptive: Determines whether or not to operate according to the condition using the value written to the classical register. Conditions can be written as Python functions. The Python function must take a list of type `unsigned int` as an argument and return a `bool`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qulacs.gate import Adaptive, X\n",
    "def func(list):\n",
    "    return list[0]==1\n",
    "gate = Adaptive(X(0), func)\n",
    "state = QuantumState(2)\n",
    "state.set_Haar_random_state()\n",
    "# func returns False, and gate is not applied\n",
    "state.set_classical_value(0,0)\n",
    "gate.update_quantum_state(state)\n",
    "# func returns True, and gate is applied\n",
    "state.set_classical_value(0,1)\n",
    "gate.update_quantum_state(state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CP-map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If Kraus rank is 1, please treat it as a single Kraus operator as described above. In other cases, please adjust the Kraus operator so that it becomes TP, and then adjust it by applying the `Identity` operator multiplied by a constant with the `multiply_scalar()` function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quantum circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Construct the quantum circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A quantum circuit is represented as a set of quantum gates. For example, you can construct a quantum circuit as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.1767767+0.j -0.1767767-0.j -0.1767767-0.j  0.1767767+0.j\n",
      " -0.1767767-0.j  0.1767767+0.j  0.1767767+0.j -0.1767767-0.j\n",
      " -0.1767767-0.j  0.1767767+0.j  0.1767767+0.j -0.1767767-0.j\n",
      "  0.1767767+0.j -0.1767767-0.j -0.1767767-0.j  0.1767767+0.j\n",
      " -0.1767767-0.j  0.1767767+0.j  0.1767767+0.j -0.1767767-0.j\n",
      "  0.1767767+0.j -0.1767767-0.j -0.1767767-0.j  0.1767767+0.j\n",
      "  0.1767767+0.j -0.1767767-0.j -0.1767767-0.j  0.1767767+0.j\n",
      " -0.1767767-0.j  0.1767767+0.j  0.1767767+0.j -0.1767767-0.j]\n"
     ]
    }
   ],
   "source": [
    "from qulacs import QuantumState, QuantumCircuit\n",
    "from qulacs.gate import Z\n",
    "n = 5\n",
    "state = QuantumState(n)\n",
    "state.set_zero_state()\n",
    "# Define quantum circuit\n",
    "circuit = QuantumCircuit(n)\n",
    "# Add hadamard gate to quantum circuit\n",
    "for i in range(n):\n",
    "    circuit.add_H_gate(i)\n",
    "# Gate can be generated and added\n",
    "for i in range(n):\n",
    "    circuit.add_gate(Z(i))\n",
    "# Apply quantum circuit to quantum state\n",
    "circuit.update_quantum_state(state)\n",
    "print(state.get_vector())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: The quantum circuit added by `add_gate` is released from memory when the quantum circuit is released. Therefore, the assigned gate cannot be reused. If you want to reuse the gate given as an argument, make a copy of itself using `gate.copy` or use the `add_gate_copy` function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate and optimize the depth of quantum circuits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By merging quantum gates into a single one, the number of quantum gates can be reduced and the time required for numerical calculations can be reduced. \n",
    "(Of course, the total calculation time will not necessarily be reduced if the number of target qubits is increased or if a quantum gate with a dedicated function is merged into a quantum gate without a dedicated function.)\n",
    "\n",
    "The code below uses the `optimize` function to repeat merging the quantum gates of the quantum circuit until the number of target qubits is reduced to three by the greedy algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "from qulacs import QuantumCircuit\n",
    "from qulacs.circuit import QuantumCircuitOptimizer\n",
    "n = 5\n",
    "depth = 10\n",
    "circuit = QuantumCircuit(n)\n",
    "for d in range(depth):\n",
    "    for i in range(n):\n",
    "        circuit.add_H_gate(i)\n",
    "# Calculate depth (depth=10)\n",
    "print(circuit.calculate_depth())\n",
    "# Optimization\n",
    "opt = QuantumCircuitOptimizer()\n",
    "# Maximum quantum gate size allowed to be created\n",
    "max_block_size = 1\n",
    "opt.optimize(circuit, max_block_size)\n",
    "# Calculate depth (depth=1へ)\n",
    "print(circuit.calculate_depth())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Obtain debug information of quantum circuits¶"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When `print` a quantum circuit, statistical information about the gates included in the quantum circuit will be displayed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** Quantum Circuit Info ***\n",
      "# of qubit: 5\n",
      "# of step : 10\n",
      "# of gate : 50\n",
      "# of 1 qubit gate: 50\n",
      "Clifford  : yes\n",
      "Gaussian  : no\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from qulacs import QuantumCircuit\n",
    "from qulacs.circuit import QuantumCircuitOptimizer\n",
    "n = 5\n",
    "depth = 10\n",
    "circuit = QuantumCircuit(n)\n",
    "for d in range(depth):\n",
    "    for i in range(n):\n",
    "        circuit.add_H_gate(i)\n",
    "print(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Observable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate observables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observables are represented as a set of Pauli operators. The Pauli operator can be defined as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qulacs import Observable\n",
    "n = 5\n",
    "coef = 2.0\n",
    "# Set Pauli operators: X_0 X_1 Y_2 Z_4\n",
    "Pauli_string = \"X 0 X 1 Y 2 Z 4\"\n",
    "observable = Observable(n)\n",
    "observable.add_operator(coef,Pauli_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate observable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An evaluation of the expected value of the observable for the state can be obtained."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.42507924552241977\n"
     ]
    }
   ],
   "source": [
    "from qulacs import Observable, QuantumState\n",
    "n = 5\n",
    "coef = 2.0\n",
    "Pauli_string = \"X 0 X 1 Y 2 Z 4\"\n",
    "observable = Observable(n)\n",
    "observable.add_operator(coef,Pauli_string)\n",
    "state = QuantumState(n)\n",
    "state.set_Haar_random_state()\n",
    "# Calculate expectation value\n",
    "value = observable.get_expectation_value(state)\n",
    "print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parametric quantum circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Defining a quantum circuit as the `ParametricQuantumCircuit` class allows you to use some functions that are useful for optimizing quantum circuits using variational methods, in addition to the usual functions of the `QuantumCircuit` class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examples of parametric quantum circuits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quantum gates with one rotation angle (X-rot, Y-rot, Z-rot, multi_qubit_pauli_rotation) can be added to quantum circuits as parametric quantum gates. For quantum gates added as parametric gates, the number of parametric gates can be extracted after the quantum circuit is constructed, and the rotation angle can be changed later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " *** Quantum State ***\n",
      " * Qubit Count : 5\n",
      " * Dimension   : 32\n",
      " * State vector : \n",
      "     (0.0644046,0.0543203)\n",
      "    (-0.0124557,0.0773343)\n",
      "   (-0.0994673,-0.0232714)\n",
      "    (-0.0906349,0.0126735)\n",
      "    (-0.0055132,0.0615354)\n",
      "       (0.0257616,0.11585)\n",
      "     (0.0572645,-0.176249)\n",
      "      (0.148752,-0.097278)\n",
      "    (0.0190231,-0.0245991)\n",
      "   (-0.00852605,0.0232178)\n",
      "    (0.00586012,0.0554068)\n",
      "     (0.0484442,-0.232187)\n",
      "    (-0.0155285,0.0231175)\n",
      "   (-0.0303796,-0.0352834)\n",
      "     (-0.183101,0.0680983)\n",
      "      (0.267338,-0.195386)\n",
      "    (-0.239673,-0.0333867)\n",
      "    (-0.155652,-0.0435336)\n",
      "       (0.223335,0.251257)\n",
      "    (-0.167392,-0.0063077)\n",
      "     (-0.127799,0.0654382)\n",
      "     (0.363626,-0.0430651)\n",
      "    (0.0865432,-0.0511235)\n",
      "      (0.0467295,0.238852)\n",
      "    (-0.0438296,0.0167142)\n",
      "     (0.0477825,0.0855392)\n",
      "    (-0.0323637,-0.121396)\n",
      "      (0.246739,0.0580693)\n",
      "     (-0.0387275,0.233282)\n",
      "     (-0.245181,0.0552884)\n",
      "(-0.000639744,-0.00135822)\n",
      "   (-0.0788815,-0.0741289)\n",
      "\n",
      "*** Quantum Circuit Info ***\n",
      "# of qubit: 5\n",
      "# of step : 41\n",
      "# of gate : 171\n",
      "# of 1 qubit gate: 150\n",
      "# of 2 qubit gate: 20\n",
      "# of 3 qubit gate: 0\n",
      "# of 4 qubit gate: 1\n",
      "Clifford  : no\n",
      "Gaussian  : no\n",
      "\n",
      "*** Parameter Info ***\n",
      "# of parameter: 151\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from qulacs import ParametricQuantumCircuit\n",
    "from qulacs import QuantumState\n",
    "import numpy as np\n",
    "n = 5\n",
    "depth = 10\n",
    "# construct parametric quantum circuit with random rotation\n",
    "circuit = ParametricQuantumCircuit(n)\n",
    "for d in range(depth):\n",
    "    for i in range(n):\n",
    "        angle = np.random.rand()\n",
    "        circuit.add_parametric_RX_gate(i,angle)\n",
    "        angle = np.random.rand()\n",
    "        circuit.add_parametric_RY_gate(i,angle)\n",
    "        angle = np.random.rand()\n",
    "        circuit.add_parametric_RZ_gate(i,angle)\n",
    "    for i in range(d%2, n-1, 2):\n",
    "        circuit.add_CNOT_gate(i,i+1)\n",
    "# add multi-qubit Pauli rotation gate as parametric gate (X_0 Y_3 Y_1 X_4)\n",
    "target = [0,3,1,4]\n",
    "pauli_ids = [1,2,2,1]\n",
    "angle = np.random.rand()\n",
    "circuit.add_parametric_multi_Pauli_rotation_gate(target, pauli_ids, angle)\n",
    "# get variable parameter count, and get current parameter\n",
    "parameter_count = circuit.get_parameter_count()\n",
    "param = [circuit.get_parameter(ind) for ind in range(parameter_count)]\n",
    "# set 3rd parameter to 0\n",
    "circuit.set_parameter(3, 0.)\n",
    "# update quantum state\n",
    "state = QuantumState(n)\n",
    "circuit.update_quantum_state(state)\n",
    "# output state and circuit info\n",
    "print(state)\n",
    "print(circuit)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.5 ('.venv': poetry)",
   "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.8"
  },
  "vscode": {
   "interpreter": {
    "hash": "9bff6d9ec148787bab095912795760501b1b5d26628b95fea09c0ffd701bfa49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}