tutorials/introduction/operator.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantum Gates and Quantum Channels\n",
    "\n",
    "In this tutorial, we will briefly introduce the concepts of quantum gates and quantum channels, and learn how to implement some common quantum gates and quantum channels in QuAIRKit.\n",
    "\n",
    "**Table of Contents**\n",
    "\n",
    "- [Quantum gates](#Quantum-gates)\n",
    "  - [Single-qubit gates](#Single-qubit-gates)\n",
    "  - [Two-qubit gates](#Two-qubit-gates)\n",
    "  - [Applying quantum gates to states](#Applying-quantum-gates-to-states)\n",
    "- [Quantum channels](#Quantum-channels)\n",
    "  - [Kraus representation](#Kraus-representation)\n",
    "  - [Choi representation](#Choi-representation)\n",
    "  - [Stinespring representation](#Stinespring-representation)\n",
    "  - [Conversion among three representations](#Conversion-among-three-representations)\n",
    "  - [Examples of quantum channels](#Examples-of-quantum-channels)\n",
    "    - [Bit flip channel](#Bit-flip-channel)\n",
    "    - [Phase flip channel](#Phase-flip-channel)\n",
    "    - [Bit-phase flip channel](#Bit-phase-flip-channel)\n",
    "    - [Depolarizing channel](#Depolarizing-channel)\n",
    "    - [Amplitude damping channel](#Amplitude-damping-channel)\n",
    "  - [Applying quantum channels to states](#Applying-quantum-channels-to-states)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "import quairkit as qkit\n",
    "from quairkit import *\n",
    "from quairkit.database.matrix import *\n",
    "from quairkit.database.random import *\n",
    "from quairkit.database.representation import *\n",
    "from quairkit.qinfo import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In QuAIRKit, the default datatype is `complex64`. If a higher precision `complex128` is required, it can be set as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dtype:  torch.complex128\n"
     ]
    }
   ],
   "source": [
    "qkit.set_dtype(\"complex128\")\n",
    "print(\"dtype: \",qkit.get_dtype())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum gates\n",
    "\n",
    "In quantum computing, a quantum gate is a basic quantum operation acting on a set of qubits. Quantum gates are the building blocks of quantum circuits, represented by unitary transformations which are reversible. Specifically, for every quantum gate $U$, there is always an another gate $U^{\\dagger}$ that undoes the transformation:\n",
    "$$\n",
    "UU^{\\dagger} = U^{\\dagger}U = I, \\tag{1}\n",
    "$$\n",
    "where $U^{\\dagger}$ is the conjugate transpose of $U$. In the following, we will list some important single-qubit gates and multi-qubit gates."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Single-qubit gates\n",
    "\n",
    "A single-qubit is a normalized vector $|\\psi\\rangle=\\alpha|0\\rangle+\\beta|1\\rangle$ parameterized by two complex numbers satisfying $|\\alpha|^{2}+|\\beta|^{2}=1$. Quantum gates on a qubit must preserve this norm, and thus are described by $2 \\times 2$ unitary matrices. Tha Pauli matrices are some of the most significant, and can be represented as:\n",
    "$$\n",
    "X = \n",
    "\\left[\n",
    "    \\begin{matrix}\n",
    "        0 & 1 \\\\\n",
    "        1 & 0 \n",
    "    \\end{matrix}\n",
    "\\right]\n",
    ";\\quad\n",
    "Y = \n",
    "\\left[\n",
    "    \\begin{matrix}\n",
    "        0 & -i \\\\\n",
    "        i & 0 \n",
    "    \\end{matrix}\n",
    "\\right]\n",
    ";\\quad\n",
    "Z = \n",
    "\\left[\n",
    "    \\begin{matrix}\n",
    "        1 & 0 \\\\\n",
    "        0 & -1 \n",
    "    \\end{matrix}\n",
    "\\right]. \\tag{2}\n",
    "$$\n",
    "One can utilize `torch` package to construct these Pauli matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The matrix form of Pauli X gate is\n",
      " tensor([[0, 1],\n",
      "        [1, 0]]) \n",
      "\n",
      "The matrix form of Pauli Y gate is\n",
      " tensor([[0.+0.j, -0.-1.j],\n",
      "        [0.+1.j, 0.+0.j]]) \n",
      "\n",
      "The matrix form of Pauli Z gate is\n",
      " tensor([[ 1,  0],\n",
      "        [ 0, -1]])\n"
     ]
    }
   ],
   "source": [
    "X = torch.tensor([[0, 1], [1, 0]])  # Pauli X matrix\n",
    "Y = torch.tensor([[0, -1j], [1j, 0]])  # Pauli Y matrix\n",
    "Z = torch.tensor([[1, 0], [0, -1]])  # Pauli Z matrix\n",
    "\n",
    "print(\"The matrix form of Pauli X gate is\\n\", X, \"\\n\")\n",
    "print(\"The matrix form of Pauli Y gate is\\n\", Y, \"\\n\")\n",
    "print(\"The matrix form of Pauli Z gate is\\n\", Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other three single-qubit quantum gates that play a important roles are the Hadamard gate, phase gate, and T($\\pi/8$) gate:\n",
    "$$\n",
    "H = \\frac{1}{\\sqrt{2}}\n",
    "\\left[\n",
    "    \\begin{matrix}\n",
    "        1 & 1 \\\\\n",
    "        1 & -1 \n",
    "    \\end{matrix}\n",
    "\\right]\n",
    ";\\quad\n",
    "S = \n",
    "\\left[\n",
    "    \\begin{matrix}\n",
    "        1 & 0 \\\\\n",
    "        0 & i \n",
    "    \\end{matrix}\n",
    "\\right]\n",
    ";\\quad\n",
    "T = \n",
    "\\left[\n",
    "    \\begin{matrix}\n",
    "        1 & 0 \\\\\n",
    "        0 & e^{i\\pi /4} \n",
    "    \\end{matrix}\n",
    "\\right]. \\tag{3}\n",
    "$$\n",
    "Also, one can utilize `torch` to construct these three matrices as followed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The matrix form of Hadamard gate is\n",
      " tensor([[ 0.7071,  0.7071],\n",
      "        [ 0.7071, -0.7071]])\n",
      "\n",
      "The matrix form of Phase gate is\n",
      " tensor([[1.+0.j, 0.+0.j],\n",
      "        [0.+0.j, 0.+1.j]])\n",
      "\n",
      "The matrix form of T gate is\n",
      " tensor([[1.0000+0.0000j, 0.0000+0.0000j],\n",
      "        [0.0000+0.0000j, 0.7071+0.7071j]])\n"
     ]
    }
   ],
   "source": [
    "sqrt_2 = torch.sqrt(torch.tensor(2))  # sqrt 2\n",
    "isq2 = 1 / sqrt_2  # 1 / sqrt 2\n",
    "# pi = torch.acos(torch.zeros(1)).item() * 2 # pi\n",
    "\n",
    "H = isq2 * torch.tensor([[1, 1], [1, -1]])  # Hadamard gate\n",
    "S = torch.tensor([[1, 0], [0, 1j]])  # Phase gate\n",
    "T = torch.tensor([[1, 0], [0, torch.exp(torch.tensor(1j * torch.pi / 4))]])  # T gate\n",
    "\n",
    "print(\"The matrix form of Hadamard gate is\\n\", H)\n",
    "print(\"\\nThe matrix form of Phase gate is\\n\", S)\n",
    "print(\"\\nThe matrix form of T gate is\\n\", T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the quantum gates mentioned above are built-in functions in QuAIRKit. Therefore, one can directly use these gates; for example the Hadamard gate can be constructed by QuAIRKit as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The matrix form of built in Hadamard gate is\n",
      " tensor([[ 0.7071+0.j,  0.7071+0.j],\n",
      "        [ 0.7071+0.j, -0.7071+0.j]])\n"
     ]
    }
   ],
   "source": [
    "H_qkit = h()  # built-in Hadamard gate\n",
    "\n",
    "print(\"The matrix form of built in Hadamard gate is\\n\", H_qkit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following introduction, built-in functions will be used for demonstration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides, the Pauli matrices generate three classes of unitary rotation gates, in the direction of $x$, $y$ and $z$ axes:\n",
    "$$\n",
    "R_{x}(\\theta) = \n",
    "\\left[\n",
    "    \\begin{matrix}\n",
    "        \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} \\\\\n",
    "        -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2}\n",
    "    \\end{matrix}\n",
    "\\right]\n",
    ";\\quad\n",
    "R_{y}(\\theta) = \n",
    "\\left[\n",
    "    \\begin{matrix}\n",
    "        \\cos\\frac{\\theta}{2} & -\\sin\\frac{\\theta}{2} \\\\\n",
    "        \\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2}\n",
    "    \\end{matrix}\n",
    "\\right]\n",
    ";\\quad\n",
    "R_{z}(\\theta) = \n",
    "\\left[\n",
    "    \\begin{matrix}\n",
    "        e^{-i\\theta/2} & 0 \\\\\n",
    "        0 & e^{i\\theta/2}\n",
    "    \\end{matrix}\n",
    "\\right]. \\tag{4}\n",
    "$$\n",
    "They can be constructed as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The matrix form of x-axis rotation gate with parameter 2.151 is\n",
      "tensor([[0.4753+0.0000j, 0.0000-0.8798j],\n",
      "        [0.0000-0.8798j, 0.4753+0.0000j]])\n",
      "\n",
      "The matrix form of y-axis rotation gate with parameter 2.151 is\n",
      "tensor([[ 0.4753+0.j, -0.8798+0.j],\n",
      "        [ 0.8798+0.j,  0.4753+0.j]])\n",
      "\n",
      "The matrix form of z-axis rotation gate with parameter 2.151 is\n",
      "tensor([[0.4753-0.8798j, 0.0000+0.0000j],\n",
      "        [0.0000+0.0000j, 0.4753+0.8798j]])\n"
     ]
    }
   ],
   "source": [
    "theta = torch.round(2*torch.pi*torch.rand(1), decimals=3) # the parameter of Pauli rotation operators\n",
    "\n",
    "Rx = rx(theta) # x-axis rotation gate\n",
    "Ry = ry(theta) # y-axis rotation gate\n",
    "Rz = rz(theta) # z-axis rotation gate\n",
    "\n",
    "print(f'The matrix form of x-axis rotation gate with parameter {theta[0].numpy()} is\\n{Rx}')\n",
    "print(f'\\nThe matrix form of y-axis rotation gate with parameter {theta[0].numpy()} is\\n{Ry}')\n",
    "print(f'\\nThe matrix form of z-axis rotation gate with parameter {theta[0].numpy()} is\\n{Rz}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Two-qubit gates\n",
    "\n",
    "A universal quantum gate set includes all single-qubit gates (such as the Pauli-X, Pauli-Y, Pauli-Z, Hadamard, and phase gates) and one two-qubit gate, like the CNOT gate.   CNOT is a quantum gate operates on two qubits: a control qubit and a target qubit. It flips the state of the target qubit if and only if the control qubit is in the state $|1\\rangle$. In the computational basis, the matrix representation of CNOT is\n",
    "$$\n",
    "\\text{CNOT} = \n",
    "\\left[\n",
    "    \\begin{matrix}\n",
    "        1 & 0 & 0 & 0 \\\\\n",
    "        0 & 1 & 0 & 0 \\\\\n",
    "        0 & 0 & 0 & 1 \\\\\n",
    "        0 & 0 & 1 & 0\n",
    "    \\end{matrix}\n",
    "\\right]. \\tag{5}\n",
    "$$\n",
    "Another important two-qubit gate is the controlled-Z gate, which applies a phase flip on the target qubit if the control qubit is in the state |1⟩, and can be represented as\n",
    "$$ \n",
    "\\text{CZ} =\n",
    "\\left[\n",
    "    \\begin{matrix}\n",
    "        1 & 0 & 0 & 0 \\\\\n",
    "        0 & 1 & 0 & 0 \\\\\n",
    "        0 & 0 & 1 & 0 \\\\\n",
    "        0 & 0 & 0 & -1\n",
    "    \\end{matrix}\n",
    "\\right]. \\tag{6}\n",
    "$$\n",
    "The swap gate is also a crucial two-qubit gate that exchanges the quantum states of two qubits, which we often refer to as SWAP. \n",
    "$$\n",
    "\\text{SWAP} = \n",
    "\\begin{bmatrix}\n",
    "    1 & 0 & 0 & 0 \\\\\n",
    "    0 & 0 & 1 & 0 \\\\\n",
    "    0 & 1 & 0 & 0 \\\\\n",
    "    0 & 0 & 0 & 1\n",
    "\\end{bmatrix}. \\tag{7}\n",
    "$$\n",
    "These two-qubit gates can be easily constructed using QuAIRKit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The matrix form of controlled-NOT gate is\n",
      " tensor([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
      "        [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],\n",
      "        [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],\n",
      "        [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j]]) \n",
      "\n",
      "The matrix form of controlled-Z gate is\n",
      " tensor([[ 1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j],\n",
      "        [ 0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j],\n",
      "        [ 0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j],\n",
      "        [ 0.+0.j,  0.+0.j,  0.+0.j, -1.+0.j]]) \n",
      "\n",
      "The matrix form of swap gate is\n",
      " tensor([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
      "        [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],\n",
      "        [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],\n",
      "        [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])\n"
     ]
    }
   ],
   "source": [
    "CNOT = cnot()  # controlled-NOT gate\n",
    "CZ = cz()  # controlled-Z gate\n",
    "SWAP = swap()  # swap gate\n",
    "\n",
    "print(\"The matrix form of controlled-NOT gate is\\n\", CNOT, \"\\n\")\n",
    "print(\"The matrix form of controlled-Z gate is\\n\", CZ, \"\\n\")\n",
    "print(\"The matrix form of swap gate is\\n\", SWAP)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Applying quantum gates to states\n",
    "\n",
    "In quantum computing, the form of a quantum gate (unitary) $U$ acting on a pure quantum state $|\\psi\\rangle$ can be represented as \n",
    "$$\n",
    "|\\phi\\rangle = U|\\psi\\rangle. \\tag{8}\n",
    "$$\n",
    "\n",
    "More generally, the evolution of a mixed quantum state (density operator) $\\rho$ under a unitary operation $U$ can be described by the equation:\n",
    "$$\n",
    "\\sigma = U\\rho U^{\\dagger}. \\tag{9}\n",
    "$$\n",
    "\n",
    "In QuAIRKit, applying any quantum gate to a `State` class, for both pure states and mixed states, can be achieved through `State.evolve`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pure output state after applying a unitary:\n",
      " tensor([[-0.3432+0.3498j],\n",
      "        [-0.5092-0.7075j]])\n",
      "\n",
      "mixed output state after applying a unitary:\n",
      " tensor([[ 0.2989+3.4694e-18j, -0.0232+3.2499e-01j],\n",
      "        [-0.0232-3.2499e-01j,  0.7011-5.0307e-17j]])\n"
     ]
    }
   ],
   "source": [
    "pure_state = random_state(num_qubits=1, rank=1) # random single-qubit pure state\n",
    "mixed_state = random_state(num_qubits=1, rank=2) # random single-qubit mixed state\n",
    "unitary = random_unitary(num_qubits=1) # random single-qubit unitary\n",
    "\n",
    "pure_state_evo = pure_state.evolve(unitary)\n",
    "mixed_state_evo = mixed_state.evolve(unitary)\n",
    "print(f\"pure output state after applying a unitary:\\n {pure_state_evo.ket}\\n\")\n",
    "print(f\"mixed output state after applying a unitary:\\n {mixed_state_evo.density_matrix}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The position of the qubit on which the quantum gate acts can be specified through `sys_idx`. The dimension of a quantum gate can be smaller than the dimension of the quantum state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state after applying a unitary on the first qubit:\n",
      " tensor([[ 0.3191-6.9389e-18j,  0.0254-1.6791e-02j,  0.0108+1.0972e-01j,\n",
      "         -0.1529-6.6787e-02j],\n",
      "        [ 0.0254+1.6791e-02j,  0.0523+3.4694e-18j, -0.1241-5.5073e-02j,\n",
      "         -0.0756-5.8328e-02j],\n",
      "        [ 0.0108-1.0972e-01j, -0.1241+5.5073e-02j,  0.4095-1.3878e-17j,\n",
      "          0.1921+7.1530e-02j],\n",
      "        [-0.1529+6.6787e-02j, -0.0756+5.8328e-02j,  0.1921-7.1530e-02j,\n",
      "          0.2191-6.9389e-18j]])\n"
     ]
    }
   ],
   "source": [
    "state = random_state(num_qubits=2)\n",
    "unitary = random_unitary(num_qubits=1)\n",
    "\n",
    "state_evo = state.evolve(unitary, sys_idx=[0])\n",
    "print(f\"state after applying a unitary on the first qubit:\\n {state_evo.density_matrix}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The application of a quantum gate on batched states is also supported."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "batched states after applying a unitary:\n",
      " \n",
      "-----------------------------------------------------\n",
      " Backend: density_matrix\n",
      " System dimension: [2]\n",
      " System sequence: [0]\n",
      " Batch size: [5]\n",
      "\n",
      " # 0:\n",
      "[[0.27+0.j   0.1 +0.23j]\n",
      " [0.1 -0.23j 0.73-0.j  ]]\n",
      " # 1:\n",
      "[[ 0.68-0.j   -0.14+0.19j]\n",
      " [-0.14-0.19j  0.32+0.j  ]]\n",
      " # 2:\n",
      "[[0.8 +0.j   0.08+0.29j]\n",
      " [0.08-0.29j 0.2 -0.j  ]]\n",
      " # 3:\n",
      "[[ 0.53+0.j   -0.19+0.04j]\n",
      " [-0.19-0.04j  0.47+0.j  ]]\n",
      " # 4:\n",
      "[[ 0.31+0.j   -0.16-0.07j]\n",
      " [-0.16+0.07j  0.69+0.j  ]]\n",
      "-----------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "state = random_state(num_qubits=1, size=5)  # 5 random single-qubit states (batched states)\n",
    "unitary = random_unitary(num_qubits=1)\n",
    "state_evo = state.evolve(unitary)\n",
    "# this is equivalent to below code\n",
    "# batch_size = 5\n",
    "# state_list = []\n",
    "# unitary = random_unitary(num_qubits=1)\n",
    "# for i in range(batch_size):\n",
    "#     state_temp = random_state(num_qubits=1)\n",
    "#     state_evo_temp = state_temp.evolve(unitary)\n",
    "#     state_list.append(state_evo_temp.density_matrix)\n",
    "# state_evo = to_state(torch.stack(state_list, dim=0))\n",
    "\n",
    "print(f\"batched states after applying a unitary:\\n {state_evo}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, one can apply batched unitaries to a `State`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state after applying batched unitaries:\n",
      " \n",
      "-----------------------------------------------------\n",
      " Backend: state_vector\n",
      " System dimension: [2]\n",
      " System sequence: [0]\n",
      " Batch size: [5]\n",
      "\n",
      " # 0:\n",
      "[-0.19-0.29j -0.82+0.45j]\n",
      " # 1:\n",
      "[0.31+0.83j 0.44+0.14j]\n",
      " # 2:\n",
      "[0.35-0.63j 0.62-0.29j]\n",
      " # 3:\n",
      "[-0.9 -0.3j -0.29+0.1j]\n",
      " # 4:\n",
      "[ 0.73+0.25j -0.1 -0.63j]\n",
      "-----------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "state = random_state(num_qubits=1)\n",
    "unitary = random_unitary(num_qubits=1, size=5) # 5 random single-qubit unitaries (batched unitaries)\n",
    "state_evo = state.evolve(unitary)\n",
    "# this is equivalent to below code\n",
    "# batch_size = 5\n",
    "# state_list = []\n",
    "# state = random_state(num_qubits=1)\n",
    "# for i in range(batch_size):\n",
    "#     unitary_temp = random_unitary(num_qubits=1)\n",
    "#     state_evo_temp = state.evolve(unitary_temp)\n",
    "#     state_list.append(state_evo_temp.density_matrix)\n",
    "# state_evo = to_state(torch.stack(state_list, dim=0))\n",
    "\n",
    "print(f\"state after applying batched unitaries:\\n {state_evo}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, one can apply quantum gates to a `State` by executing a `Circuit` object on it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the diagram of the quantum circuit:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 124x110 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_qubits = 2  # number of qubits\n",
    "\n",
    "cir = Circuit(num_qubits)  # construct a quantum circuit\n",
    "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, 1])  # Add CNOT gate to qubit 0 and 1\n",
    "\n",
    "print(\"the diagram of the quantum circuit:\")\n",
    "cir.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have constructed a quantum circuit that includes a Hadamard gate, two Pauli X gates and a CNOT gate, as shown above. We then can execute this quantum circuit on a `State`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "output state after applying a quantum circuit:\n",
      " \n",
      "-----------------------------------------------------\n",
      " Backend: density_matrix\n",
      " System dimension: [2, 2]\n",
      " System sequence: [0, 1]\n",
      "[[ 0.12+0.j    0.06-0.08j -0.18-0.04j  0.07+0.07j]\n",
      " [ 0.06+0.08j  0.12+0.j   -0.05-0.24j -0.03+0.07j]\n",
      " [-0.18+0.04j -0.05+0.24j  0.65+0.j   -0.13-0.09j]\n",
      " [ 0.07-0.07j -0.03-0.07j -0.13+0.09j  0.11+0.j  ]]\n",
      "-----------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "state = random_state(num_qubits=2)\n",
    "output_state = cir(state)  # run the circuit on a state\n",
    "\n",
    "print(f\"output state after applying a quantum circuit:\\n {output_state}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This method also works for batched states."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "output batched states after applying a quantum circuit:\n",
      " \n",
      "-----------------------------------------------------\n",
      " Backend: density_matrix\n",
      " System dimension: [2, 2]\n",
      " System sequence: [0, 1]\n",
      " Batch size: [5]\n",
      "\n",
      " # 0:\n",
      "[[ 0.14+0.j   -0.14+0.07j  0.1 -0.07j  0.07-0.03j]\n",
      " [-0.14-0.07j  0.41+0.j   -0.11+0.13j -0.16-0.16j]\n",
      " [ 0.1 +0.07j -0.11-0.13j  0.26+0.j    0.  -0.01j]\n",
      " [ 0.07+0.03j -0.16+0.16j  0.  +0.01j  0.19+0.j  ]]\n",
      " # 1:\n",
      "[[ 0.27+0.j    0.  -0.28j  0.11+0.09j  0.05-0.08j]\n",
      " [ 0.  +0.28j  0.52+0.j   -0.17+0.05j  0.07+0.07j]\n",
      " [ 0.11-0.09j -0.17-0.05j  0.12+0.j   -0.02-0.07j]\n",
      " [ 0.05+0.08j  0.07-0.07j -0.02+0.07j  0.09+0.j  ]]\n",
      " # 2:\n",
      "[[ 0.34+0.j    0.02-0.01j  0.24+0.15j  0.12-0.14j]\n",
      " [ 0.02+0.01j  0.14+0.j   -0.01+0.06j -0.04+0.03j]\n",
      " [ 0.24-0.15j -0.01-0.06j  0.26+0.j    0.08-0.12j]\n",
      " [ 0.12+0.14j -0.04-0.03j  0.08+0.12j  0.27+0.j  ]]\n",
      " # 3:\n",
      "[[ 0.23+0.j    0.07+0.16j  0.03+0.03j -0.11-0.1j ]\n",
      " [ 0.07-0.16j  0.32+0.j    0.08-0.08j -0.06+0.18j]\n",
      " [ 0.03-0.03j  0.08+0.08j  0.08+0.j   -0.03-0.01j]\n",
      " [-0.11+0.1j  -0.06-0.18j -0.03+0.01j  0.37+0.j  ]]\n",
      " # 4:\n",
      "[[ 0.14+0.j   -0.07+0.16j  0.09+0.05j -0.06-0.11j]\n",
      " [-0.07-0.16j  0.47+0.j    0.06-0.33j -0.12+0.15j]\n",
      " [ 0.09-0.05j  0.06+0.33j  0.25+0.j   -0.11-0.06j]\n",
      " [-0.06+0.11j -0.12-0.15j -0.11+0.06j  0.13+0.j  ]]\n",
      "-----------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "state = random_state(num_qubits=2, size=5)  # 5 random 2-qubit states (batched states)\n",
    "output_state = cir(state)  # run the circuit on batched states\n",
    "# this is equivalent to below code\n",
    "# batch_size = 5\n",
    "# state_list = []\n",
    "# for i in range(batch_size):\n",
    "#     state = random_state(num_qubits=2)\n",
    "#     output_state_temp = cir(state)\n",
    "#     state_list.append(output_state_temp.density_matrix)\n",
    "#     print(output_state_temp)\n",
    "# output_states = to_state(torch.stack(state_list, dim=0))\n",
    "\n",
    "print(f\"output batched states after applying a quantum circuit:\\n {output_state}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The table below provides some common quantum gates that are built in QuAIRKit by name and the corresponding unitary matrices.\n",
    "\n",
    "| Gate Name | Symbol | Matrix Presentation |\n",
    "|:---:|:---:|:---:|\n",
    "| Pauli X gate  |$$X$$|  $$ \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix} $$ |\n",
    "| Pauli Y gate  |$$Y$$|  $$ \\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix} $$ |\n",
    "| Pauli Z gate  |$$Z$$|  $$ \\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix} $$ |\n",
    "| Hadamard gate |$$H$$|  $$ \\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 & 1 \\\\ 1 & -1 \\end{bmatrix} $$ |\n",
    "| Phase gate |$$S$$|  $$ \\begin{bmatrix} 1 & 0 \\\\ 0 & i \\end{bmatrix} $$ |\n",
    "| $\\pi / 8$ gate |$$T$$|  $$ \\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i\\pi/4} \\end{bmatrix} $$ |\n",
    "| $x$-axis rotation gate |$$R_{x}(\\theta) $$|  $$ \\begin{bmatrix} \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} \\\\ -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix} $$ |\n",
    "| $y$-axis rotation gate |$$R_{y}(\\theta)$$|  $$ \\begin{bmatrix} \\cos\\frac{\\theta}{2} & -\\sin\\frac{\\theta}{2} \\\\ \\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix} $$ |\n",
    "| $z$-axis rotation gate |$$R_{z}(\\theta)$$|  $$ \\begin{bmatrix} e^{-i\\theta/2} & 0 \\\\ 0 & e^{i\\theta/2} \\end{bmatrix} $$ |\n",
    "| Controlled Not gate |$$\\text{CNOT}$$|  $$ \\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\end{bmatrix}$$ |\n",
    "| Controlled Z gate |$$\\text{CZ}$$|  $$ \\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 0 & 0 & -1 \\end{bmatrix}$$ |\n",
    "| Swap gate |$$\\text{SWAP}$$|  $$ \\begin{bmatrix} 1 & 0 & 0 & 0 \\\\0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\end{bmatrix}$$ |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum channels\n",
    "\n",
    "Quantum channel is a communication channel that can transmit quantum (and classical) information, which can be defined as a linear, completely positive, trace preserving (CPTP) map between two linear operator space. Quantum channel is a general formalism to describe quantum operation on quantum states. There are three types of commonly used representations of a quantum channel: Kraus, Choi, and Stinespring representations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Kraus representation\n",
    "\n",
    "For a quantum channel $\\mathcal{N}(\\cdot)$, its Kraus representation can be expressed as:\n",
    "$$\n",
    "\\mathcal{N}(\\rho) = \\sum_{i} K_{i}\\rho K_{i}^{\\dagger}, \\tag{10}\n",
    "$$\n",
    "\n",
    "where $\\{K_{i}\\}$ are called the Kraus operators of the channel $\\mathcal{N}$, satisfying the condition $\\sum_{i}K_{i}^{\\dagger}K_{i}=I$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Choi representation\n",
    "\n",
    "There is another representation of a channel known as the Choi representation, or Choi operator. The Choi operator corresponding to the channel $\\mathcal{N}_{A\\rightarrow B}$ is given by the following expression:\n",
    "$$\n",
    "\\Gamma^{\\mathcal{N}}_{AB} = \\mathcal{N}_{A^{\\prime}\\rightarrow B}(|\\Gamma\\rangle\\langle\\Gamma|_{AA^{\\prime}}) = \\sum_{i,j}|i\\rangle\\langle j|\\otimes \\mathcal{N} (|i\\rangle\\langle j|_{A^{\\prime}}), \\tag{11}\n",
    "$$\n",
    "wher $\\mathcal{H}_{A^{\\prime}}$ is isomorphic to Hilbert space $\\mathcal{H}_{A}$ corresponding to the channel input system $A$, and $|\\Gamma\\rangle_{AA} = \\sum_{i}|i,i\\rangle_{AA}$. The rank of $\\Gamma^{\\mathcal{N}}_{AB}$ is referred to as the Choi rank of the channel $\\mathcal{N}_{A\\rightarrow B}$.\n",
    "\n",
    "With the Chio operator, we can calculate the result of the channel's action. Let $\\rho_{A}$ be a quantum state in the system $A$. Then the action of $\\mathcal{N}_{A\\rightarrow B}$ on $\\rho_{A}$ can be expressed in terms of the Choi operator $\\Gamma_{AB}^{\\mathcal{N}}$ as follows:\n",
    "$$\n",
    "\\mathcal{N}_{A\\rightarrow B}(\\rho_{A}) = \\mathrm{tr}_{A}\\left[(\\rho_{A}^{T} \\otimes I_{B}) \\Gamma_{AB}^{\\mathcal{N}} \\right] = \\langle\\Gamma|_{A^{\\prime}A}(\\rho_{A}\\otimes\\Gamma_{AB}^{\\mathcal{N}})|\\Gamma\\rangle_{A^{\\prime}A}. \\tag{12}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stinespring representation\n",
    "\n",
    "Generally speaking, the Kraus operators and the Choi operator mentioned above are the two most commonly used and fundamental representations. Additionally, for any quantum channel $\\mathcal{N}: \\mathcal{D}(\\mathcal{H}_{A}) \\rightarrow \\mathcal{D}(\\mathcal{H}_{B})$, and a Hilbert space $\\mathcal{H}_{E}$ with a dimension equal to the Choi rank of $\\mathcal{N}$, there exists an isometric transformation $V: \\mathcal{H}_{A} \\rightarrow \\mathcal{H}_{B} \\otimes \\mathcal{H}_{E}$ such that for all $\\rho_{A} \\in \\mathcal{D}(\\mathcal{H}_{A})$,\n",
    "$$\n",
    "\\mathrm{tr}_{E}(V\\rho_{A}V^{\\dagger}) = \\mathcal{N}(\\rho_{A}), \\tag{13}\n",
    "$$\n",
    "where isometric transformation $V$ is defined by $V^{\\dagger}V = I_{A}$. This is the Stinespring representation of a quantum channel."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conversion among three representations\n",
    "\n",
    "Note that the three representations of a quantum channel are equivalent, and they can be converted to each other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kraus representation of a quantum channel:\n",
      " tensor([[[ 0.6951+0.3158j, -0.0702+0.0241j],\n",
      "         [ 0.0831+0.1243j,  0.9700-0.0503j]],\n",
      "\n",
      "        [[ 0.0687+0.2816j, -0.1932+0.0771j],\n",
      "         [-0.5543-0.0587j,  0.0791-0.0387j]]])\n",
      "\n",
      "Choi representation of the same quantum channel:\n",
      " tensor([[ 0.6669+0.0000j,  0.0424-0.2122j, -0.0328-0.0987j,  0.6529+0.3662j],\n",
      "        [ 0.0424+0.2122j,  0.3331+0.0000j,  0.0998+0.0433j,  0.0328+0.0987j],\n",
      "        [-0.0328+0.0987j,  0.0998-0.0433j,  0.0488+0.0000j, -0.0876+0.0185j],\n",
      "        [ 0.6529-0.3662j,  0.0328-0.0987j, -0.0876-0.0185j,  0.9512+0.0000j]])\n",
      "\n",
      "Stinespring representation of the same quantum channel:\n",
      " tensor([[ 0.6951+0.3158j, -0.0702+0.0241j],\n",
      "        [ 0.0687+0.2816j, -0.1932+0.0771j],\n",
      "        [ 0.0831+0.1243j,  0.9700-0.0503j],\n",
      "        [-0.5543-0.0587j,  0.0791-0.0387j]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Kraus representation of a random channel\n",
    "kraus_repr = random_channel(num_qubits=1, target=\"kraus\")\n",
    "\n",
    "# Choi representation of the same random channel\n",
    "choi_repr = channel_repr_convert(kraus_repr, source=\"kraus\", target=\"choi\")\n",
    "\n",
    "# Stinespring representation of the same random channel\n",
    "stin_repr = channel_repr_convert(kraus_repr, source=\"kraus\", target=\"stinespring\")\n",
    "\n",
    "\n",
    "print(f\"Kraus representation of a quantum channel:\\n {kraus_repr}\\n\")\n",
    "print(f\"Choi representation of the same quantum channel:\\n {choi_repr}\\n\")\n",
    "print(f\"Stinespring representation of the same quantum channel:\\n {stin_repr}\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examples of quantum channels\n",
    "\n",
    "In this part, some concrete examples of quantum channels are provided."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bit flip channel\n",
    "\n",
    "The bit flip channel flips the state of a qubit from $|0\\rangle$ to $|1\\rangle$ or $|1\\rangle$ to $|0\\rangle$ with probability $1-p$. Its Kraus operators are:\n",
    "$$\n",
    "K_{0}=\\sqrt{p}I=\\sqrt{p}\n",
    "\\begin{bmatrix}\n",
    "1&0\\\\\n",
    "0&1\n",
    "\\end{bmatrix}\n",
    ",\\quad\n",
    "K_{1}=\\sqrt{1-p}X=\\sqrt{1-p}\n",
    "\\begin{bmatrix}\n",
    "0&1\\\\\n",
    "1&0\n",
    "\\end{bmatrix}. \\tag{14}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kraus representation of a bit flip channel with probability 0.5:\n",
      " tensor([[[0.7071+0.j, 0.0000+0.j],\n",
      "         [0.0000+0.j, 0.7071+0.j]],\n",
      "\n",
      "        [[0.0000+0.j, 0.7071+0.j],\n",
      "         [0.7071+0.j, 0.0000+0.j]]])\n",
      "\n",
      "Choi representation of a bit flip channel with probability 0.5:\n",
      " tensor([[0.5000+0.j, 0.0000+0.j, 0.0000+0.j, 0.5000+0.j],\n",
      "        [0.0000+0.j, 0.5000+0.j, 0.5000+0.j, 0.0000+0.j],\n",
      "        [0.0000+0.j, 0.5000+0.j, 0.5000+0.j, 0.0000+0.j],\n",
      "        [0.5000+0.j, 0.0000+0.j, 0.0000+0.j, 0.5000+0.j]])\n",
      "\n",
      "Stinespring representation of a bit flip channel with probability 0.5:\n",
      " tensor([[0.7071+0.j, 0.0000+0.j],\n",
      "        [0.0000+0.j, 0.7071+0.j],\n",
      "        [0.0000+0.j, 0.7071+0.j],\n",
      "        [0.7071+0.j, 0.0000+0.j]])\n"
     ]
    }
   ],
   "source": [
    "probs = 0.5 # probability\n",
    "bit_flip_kraus_repr = bit_flip_kraus(probs) # Kraus representation\n",
    "bit_flip_choi_repr = channel_repr_convert(bit_flip_kraus_repr, source=\"kraus\", target=\"choi\") # Choi representation\n",
    "bit_flip_stin_repr = channel_repr_convert(bit_flip_kraus_repr, source=\"kraus\", target=\"stinespring\") # Stinespring representation\n",
    "\n",
    "print(f\"Kraus representation of a bit flip channel with probability {probs}:\\n {bit_flip_kraus_repr}\\n\")\n",
    "print(f\"Choi representation of a bit flip channel with probability {probs}:\\n {bit_flip_choi_repr}\\n\")\n",
    "print(f\"Stinespring representation of a bit flip channel with probability {probs}:\\n {bit_flip_stin_repr}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Phase flip channel\n",
    "\n",
    "The phase flip channel flips the sign of the phase of a qubit with probability $1-p$. It has Kraus operators:\n",
    "$$\n",
    "K_{0}=\\sqrt{p}I=\\sqrt{p}\n",
    "\\begin{bmatrix}\n",
    "1&0\\\\\n",
    "0&1\n",
    "\\end{bmatrix}\n",
    ",\\quad\n",
    "K_{1}=\\sqrt{1-p}Z=\\sqrt{1-p}\n",
    "\\begin{bmatrix}\n",
    "1&0\\\\\n",
    "0&-1\n",
    "\\end{bmatrix}. \\tag{15}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kraus representation of a phase flip channel with probability 0.5:\n",
      " tensor([[[ 0.7071+0.j,  0.0000+0.j],\n",
      "         [ 0.0000+0.j,  0.7071+0.j]],\n",
      "\n",
      "        [[ 0.7071+0.j,  0.0000+0.j],\n",
      "         [ 0.0000+0.j, -0.7071+0.j]]])\n",
      "\n",
      "Choi representation of a phase flip channel with probability 0.5:\n",
      " tensor([[1.0000+0.j, 0.0000+0.j, 0.0000+0.j, 0.0000+0.j],\n",
      "        [0.0000+0.j, 0.0000+0.j, 0.0000+0.j, 0.0000+0.j],\n",
      "        [0.0000+0.j, 0.0000+0.j, 0.0000+0.j, 0.0000+0.j],\n",
      "        [0.0000+0.j, 0.0000+0.j, 0.0000+0.j, 1.0000+0.j]])\n",
      "\n",
      "Stinespring representation of a phase flip channel with probability 0.5:\n",
      " tensor([[ 0.7071+0.j,  0.0000+0.j],\n",
      "        [ 0.7071+0.j,  0.0000+0.j],\n",
      "        [ 0.0000+0.j,  0.7071+0.j],\n",
      "        [ 0.0000+0.j, -0.7071+0.j]])\n"
     ]
    }
   ],
   "source": [
    "probs = 0.5 # probability\n",
    "phase_flip_kraus_repr = phase_flip_kraus(probs) # Kraus representation\n",
    "phase_flip_choi_repr = channel_repr_convert(phase_flip_kraus_repr, source=\"kraus\", target=\"choi\") # Choi representation\n",
    "phase_flip_stin_repr = channel_repr_convert(phase_flip_kraus_repr, source=\"kraus\", target=\"stinespring\") # Stinespring representation\n",
    "\n",
    "print(f\"Kraus representation of a phase flip channel with probability {probs}:\\n {phase_flip_kraus_repr}\\n\")\n",
    "print(f\"Choi representation of a phase flip channel with probability {probs}:\\n {phase_flip_choi_repr}\\n\")\n",
    "print(f\"Stinespring representation of a phase flip channel with probability {probs}:\\n {phase_flip_stin_repr}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bit-phase flip channel\n",
    "\n",
    "Bit-phase flip channel is the combination of phase flip and bit flip. Since $Y=iXZ$, bit-phase flip channel takes the Kraus operators\n",
    "$$\n",
    "K_{0}=\\sqrt{p}I=\\sqrt{p}\n",
    "\\begin{bmatrix}\n",
    "1&0\\\\\n",
    "0&1\n",
    "\\end{bmatrix}\n",
    ",\\quad\n",
    "K_{1}=\\sqrt{1-p}Y=\\sqrt{1-p}\n",
    "\\begin{bmatrix}\n",
    "0&-i\\\\\n",
    "i&0\n",
    "\\end{bmatrix}. \\tag{16}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kraus representation of a bit-phase flip channel with probability 0.5:\n",
      " tensor([[[0.7071+0.0000j, 0.0000+0.0000j],\n",
      "         [0.0000+0.0000j, 0.7071+0.0000j]],\n",
      "\n",
      "        [[0.0000+0.0000j, 0.0000-0.7071j],\n",
      "         [0.0000+0.7071j, 0.0000+0.0000j]]])\n",
      "\n",
      "Choi representation of a bit-phase flip channel with probability 0.5:\n",
      " tensor([[ 0.5000+0.j,  0.0000+0.j,  0.0000+0.j,  0.5000+0.j],\n",
      "        [ 0.0000+0.j,  0.5000+0.j, -0.5000+0.j,  0.0000+0.j],\n",
      "        [ 0.0000+0.j, -0.5000+0.j,  0.5000+0.j,  0.0000+0.j],\n",
      "        [ 0.5000+0.j,  0.0000+0.j,  0.0000+0.j,  0.5000+0.j]])\n",
      "\n",
      "Stinespring representation of a bit-phase flip channel with probability 0.5:\n",
      " tensor([[0.7071+0.0000j, 0.0000+0.0000j],\n",
      "        [0.0000+0.0000j, 0.0000-0.7071j],\n",
      "        [0.0000+0.0000j, 0.7071+0.0000j],\n",
      "        [0.0000+0.7071j, 0.0000+0.0000j]])\n"
     ]
    }
   ],
   "source": [
    "probs = 0.5 # probability\n",
    "bit_phase_flip_kraus_repr = bit_phase_flip_kraus(probs) # Kraus representation\n",
    "bit_phase_flip_choi_repr = channel_repr_convert(bit_phase_flip_kraus_repr, source=\"kraus\", target=\"choi\") # Choi representation\n",
    "bit_phase_flip_stin_repr = channel_repr_convert(bit_phase_flip_kraus_repr, source=\"kraus\", target=\"stinespring\") # Stinespring representation\n",
    "\n",
    "print(f\"Kraus representation of a bit-phase flip channel with probability {probs}:\\n {bit_phase_flip_kraus_repr}\\n\")\n",
    "print(f\"Choi representation of a bit-phase flip channel with probability {probs}:\\n {bit_phase_flip_choi_repr}\\n\")\n",
    "print(f\"Stinespring representation of a bit-phase flip channel with probability {probs}:\\n {bit_phase_flip_stin_repr}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Depolarizing channel\n",
    "\n",
    "The depolarizing channel represents a significant type of quantum noise. Consider a single-qubit undergoing depolarization with probability $p$, namely, it is replaced by the completely mixed state $I/2$ with probability $p$. And the qubit remains unchanged with probability $1 - p$,. The state after such a depolarizing channel is\n",
    "$$\n",
    "\\varepsilon(\\rho) = \\frac{pI}{2} + (1-p)\\rho. \\tag{17}\n",
    "$$\n",
    "It can be shown that the depolarizing channel has Kraus operators $\\{\\sqrt{1-3p'/4}I, \\sqrt{p'}X/2, \\sqrt{p'}Y/2, \\sqrt{p'}Z/2 \\}$, leading to\n",
    "$$\n",
    "\\varepsilon(\\rho) = \\left(1-\\frac{3p'}{4}\\right)\\rho+\\frac{p'}{4}(X\\rho X + Y\\rho Y + Z\\rho Z). \\tag{18}\n",
    "$$\n",
    "There is an implementation of depolarizing channel with given parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kraus representation of a depolarizing channel with probability 0.5:\n",
      " tensor([[[ 0.7906+0.0000j,  0.0000+0.0000j],\n",
      "         [ 0.0000+0.0000j,  0.7906+0.0000j]],\n",
      "\n",
      "        [[ 0.0000+0.0000j,  0.3536+0.0000j],\n",
      "         [ 0.3536+0.0000j,  0.0000+0.0000j]],\n",
      "\n",
      "        [[ 0.0000+0.0000j,  0.0000-0.3536j],\n",
      "         [ 0.0000+0.3536j,  0.0000+0.0000j]],\n",
      "\n",
      "        [[ 0.3536+0.0000j,  0.0000+0.0000j],\n",
      "         [ 0.0000+0.0000j, -0.3536+0.0000j]]])\n",
      "\n",
      "Choi representation of a depolarizing channel with probability 0.5:\n",
      " tensor([[0.7500+0.j, 0.0000+0.j, 0.0000+0.j, 0.5000+0.j],\n",
      "        [0.0000+0.j, 0.2500+0.j, 0.0000+0.j, 0.0000+0.j],\n",
      "        [0.0000+0.j, 0.0000+0.j, 0.2500+0.j, 0.0000+0.j],\n",
      "        [0.5000+0.j, 0.0000+0.j, 0.0000+0.j, 0.7500+0.j]])\n",
      "\n",
      "Stinespring representation of a depolarizing channel with probability 0.5:\n",
      " tensor([[ 0.7906+0.0000j,  0.0000+0.0000j],\n",
      "        [ 0.0000+0.0000j,  0.3536+0.0000j],\n",
      "        [ 0.0000+0.0000j,  0.0000-0.3536j],\n",
      "        [ 0.3536+0.0000j,  0.0000+0.0000j],\n",
      "        [ 0.0000+0.0000j,  0.7906+0.0000j],\n",
      "        [ 0.3536+0.0000j,  0.0000+0.0000j],\n",
      "        [ 0.0000+0.3536j,  0.0000+0.0000j],\n",
      "        [ 0.0000+0.0000j, -0.3536+0.0000j]])\n"
     ]
    }
   ],
   "source": [
    "probs = 0.5 # probability\n",
    "depolarizing_kraus_repr = depolarizing_kraus(probs) # Kraus representation\n",
    "depolarizing_choi_repr = channel_repr_convert(depolarizing_kraus_repr, source=\"kraus\", target=\"choi\") # Choi representation\n",
    "depolarizing_stin_repr = channel_repr_convert(depolarizing_kraus_repr, source=\"kraus\", target=\"stinespring\") # Stinespring representation\n",
    "\n",
    "print(f\"Kraus representation of a depolarizing channel with probability {probs}:\\n {depolarizing_kraus_repr}\\n\")\n",
    "print(f\"Choi representation of a depolarizing channel with probability {probs}:\\n {depolarizing_choi_repr}\\n\")\n",
    "print(f\"Stinespring representation of a depolarizing channel with probability {probs}:\\n {depolarizing_stin_repr}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Amplitude damping channel\n",
    "\n",
    "The amplitude damping channel with decay parameter $\\gamma\\in[0,1]$ is the channel given with the two Kraus operators defined as\n",
    "$$\n",
    "K_0 = |0\\rangle\\langle 0| + \\sqrt{1-\\gamma}|1\\rangle\\langle 1| = \n",
    "\\begin{bmatrix}\n",
    "1&0\\\\\n",
    "0&\\sqrt{1-\\gamma}\n",
    "\\end{bmatrix}\n",
    ",\\quad\n",
    "K_{1} = \\sqrt{\\gamma}|0\\rangle\\langle 1| = \n",
    "\\begin{bmatrix}\n",
    "0&\\sqrt{\\gamma}\\\\\n",
    "0&0\n",
    "\\end{bmatrix}. \\tag{19}\n",
    "$$\n",
    "Examples of amplitude damping channel in three representations are provided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kraus representation of a amplitude damping channel with parameter 0.5:\n",
      " tensor([[[1.0000+0.j, 0.0000+0.j],\n",
      "         [0.0000+0.j, 0.7071+0.j]],\n",
      "\n",
      "        [[0.0000+0.j, 0.7071+0.j],\n",
      "         [0.0000+0.j, 0.0000+0.j]]])\n",
      "\n",
      "Choi representation of a amplitude damping channel with parameter 0.5:\n",
      " tensor([[1.0000+0.j, 0.0000+0.j, 0.0000+0.j, 0.7071+0.j],\n",
      "        [0.0000+0.j, 0.0000+0.j, 0.0000+0.j, 0.0000+0.j],\n",
      "        [0.0000+0.j, 0.0000+0.j, 0.5000+0.j, 0.0000+0.j],\n",
      "        [0.7071+0.j, 0.0000+0.j, 0.0000+0.j, 0.5000+0.j]])\n",
      "\n",
      "Stinespring representation of a amplitude damping channel with parameter 0.5:\n",
      " tensor([[1.0000+0.j, 0.0000+0.j],\n",
      "        [0.0000+0.j, 0.7071+0.j],\n",
      "        [0.0000+0.j, 0.7071+0.j],\n",
      "        [0.0000+0.j, 0.0000+0.j]])\n"
     ]
    }
   ],
   "source": [
    "gamma = 0.5 # parameter gamma\n",
    "amplitude_damping_kraus_repr = amplitude_damping_kraus(gamma) # Kraus representation\n",
    "amplitude_damping_choi_repr = channel_repr_convert(amplitude_damping_kraus_repr, source=\"kraus\", target=\"choi\") # Choi representation\n",
    "amplitude_damping_stin_repr = channel_repr_convert(amplitude_damping_kraus_repr, source=\"kraus\", target=\"stinespring\") # Stinespring representation\n",
    "\n",
    "print(f\"Kraus representation of a amplitude damping channel with parameter {gamma}:\\n {amplitude_damping_kraus_repr}\\n\")\n",
    "print(f\"Choi representation of a amplitude damping channel with parameter {gamma}:\\n {amplitude_damping_choi_repr}\\n\")\n",
    "print(f\"Stinespring representation of a amplitude damping channel with parameter {gamma}:\\n {amplitude_damping_stin_repr}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Applying quantum channels to states\n",
    "\n",
    "In QuAIRKit, applying any quantum channel to a `State` class can be achieved through `State.transform`. Notice that `State.transform` does not support stinespring representations. It can be checked that the state after applying a quantum channel in Choi representation is the same as the state after applying the same quantum channel in Kraus representation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state after applying a quantum channel in Kraus representation:\n",
      " tensor([[0.7352+6.9389e-18j, 0.0020-2.3601e-01j],\n",
      "        [0.0020+2.3601e-01j, 0.2648-3.4694e-18j]])\n",
      "\n",
      "state after applying a quantum channel in Choi representation:\n",
      " tensor([[0.7352+0.0000j, 0.0020-0.2360j],\n",
      "        [0.0020+0.2360j, 0.2648+0.0000j]])\n"
     ]
    }
   ],
   "source": [
    "state = random_state(num_qubits=1)\n",
    "kraus_repr = random_channel(num_qubits=1, target=\"kraus\") # random sigle-qubit quantum channel (Kraus representation)\n",
    "choi_repr = channel_repr_convert(kraus_repr, source=\"kraus\", target=\"choi\") # Choi representation\n",
    "\n",
    "state_kraus = state.transform(kraus_repr, repr_type=\"kraus\")\n",
    "state_choi = state.transform(choi_repr, repr_type=\"choi\")\n",
    "\n",
    "print(f\"state after applying a quantum channel in Kraus representation:\\n {state_kraus.density_matrix}\\n\")\n",
    "print(f\"state after applying a quantum channel in Choi representation:\\n {state_choi.density_matrix}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The position of the qubit on which the quantum channel acts can be specified through `sys_idx`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state after applying a quantum channel on the first qubit:\n",
      " tensor([[ 0.3431+1.3878e-17j,  0.0128-3.8003e-02j,  0.1459+9.0796e-02j,\n",
      "         -0.1977+9.7453e-02j],\n",
      "        [ 0.0128+3.8003e-02j,  0.1728-6.9389e-18j,  0.0826-7.0578e-02j,\n",
      "         -0.0519-2.5673e-02j],\n",
      "        [ 0.1459-9.0796e-02j,  0.0826+7.0578e-02j,  0.2661+0.0000e+00j,\n",
      "         -0.1339+2.5577e-02j],\n",
      "        [-0.1977-9.7453e-02j, -0.0519+2.5673e-02j, -0.1339-2.5577e-02j,\n",
      "          0.2180-3.4694e-18j]])\n"
     ]
    }
   ],
   "source": [
    "state = random_state(num_qubits=2)\n",
    "kraus_repr = random_channel(num_qubits=1, target=\"kraus\")\n",
    "\n",
    "state_trans = state.transform(kraus_repr, sys_idx=[0])\n",
    "print(f\"state after applying a quantum channel on the first qubit:\\n {state_trans.density_matrix}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For batched states, the application of a quantum channel is also supported."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "batched states after applying a quantum channel:\n",
      " \n",
      "-----------------------------------------------------\n",
      " Backend: state_vector\n",
      " System dimension: [2]\n",
      " System sequence: [0]\n",
      " Batch size: [5]\n",
      "\n",
      " # 0:\n",
      "[-0.19-0.29j -0.82+0.45j]\n",
      " # 1:\n",
      "[0.31+0.83j 0.44+0.14j]\n",
      " # 2:\n",
      "[0.35-0.63j 0.62-0.29j]\n",
      " # 3:\n",
      "[-0.9 -0.3j -0.29+0.1j]\n",
      " # 4:\n",
      "[ 0.73+0.25j -0.1 -0.63j]\n",
      "-----------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "state = random_state(num_qubits=1, size=5)  # 5 random single-qubit states (batched states)\n",
    "kraus_repr = random_channel(num_qubits=1, target=\"kraus\")\n",
    "state_trans = state.transform(kraus_repr, repr_type=\"kraus\")\n",
    "# this is equivalent to below code\n",
    "# batch_size = 5\n",
    "# state_list = []\n",
    "# kraus_repr = random_channel(num_qubits=1, target=\"kraus\")\n",
    "# for i in range(batch_size):\n",
    "#     state_temp = random_state(num_qubits=1)\n",
    "#     state_trans_temp = state_temp.transform(kraus_repr, repr_type=\"kraus\")\n",
    "#     state_list.append(state_trans_temp.density_matrix)\n",
    "# state_trans = to_state(torch.stack(state_list, dim=0))\n",
    "\n",
    "print(f\"batched states after applying a quantum channel:\\n {state_evo}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At the present, `State.transform` does not support batched quantum channels."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The table below provides some important single-qubit quantum channels that are built in QuAIRKit by name and the corresponding Kraus operators.\n",
    "\n",
    "| Channel Name | Kraus operators |\n",
    "|:---:|:---:|\n",
    "| Bit flip channel | $$ \\sqrt{p}\\begin{bmatrix} 1&0\\\\0&1 \\end{bmatrix}, \\sqrt{1-p}\\begin{bmatrix} 0&1\\\\1&0 \\end{bmatrix}$$ |\n",
    "| Phase flip channel | $$ \\sqrt{p}\\begin{bmatrix} 1&0\\\\0&1 \\end{bmatrix}, \\sqrt{1-p}\\begin{bmatrix} 1&0\\\\0&-1 \\end{bmatrix}$$ |\n",
    "| Bit-phase flip channel | $$ \\sqrt{p}\\begin{bmatrix} 1&0\\\\0&1 \\end{bmatrix}, \\sqrt{1-p}\\begin{bmatrix} 0&-i\\\\i&0 \\end{bmatrix} $$ |\n",
    "| Depolarizing channel | $$ \\sqrt{1-\\frac{3p}{4}}\\begin{bmatrix}1&0\\\\0&1\\end{bmatrix}, \\sqrt{\\frac{p}{4}}\\begin{bmatrix}0&1\\\\1&0\\end{bmatrix}, \\sqrt{\\frac{p}{4}}\\begin{bmatrix}0&-i\\\\i&0\\end{bmatrix}, \\sqrt{\\frac{p}{4}}\\begin{bmatrix}1&0\\\\0&-1\\end{bmatrix}$$ |\n",
    "| Amplitude damping channel | $$\\begin{bmatrix} 1&0\\\\0&\\sqrt{1-\\gamma} \\end{bmatrix}, \\begin{bmatrix} 0&\\sqrt{\\gamma}\\\\0&0 \\end{bmatrix}$$ |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "[1] Nielsen, Michael A., and Isaac L. Chuang. *Quantum computation and quantum information*. Cambridge university press, 2010.\n",
    "\n",
    "[2] Khatri, Sumeet, and Mark M. Wilde. *Principles of quantum communication theory: A modern approach*. arXiv preprint arXiv:2011.04672 (2020)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Table: A reference of notation conventions in this tutorial.*\n",
    "\n",
    "| Symbol        | Variant          | Description                               |\n",
    "|:---------------:|:------------------:|-------------------------------------------|\n",
    "|$U$||unitary matrix|\n",
    "| $\\vert \\psi \\rangle$ | $\\vert \\phi \\rangle$ | pure quantum state |\n",
    "|$\\rho$|$\\sigma$, $\\rho_{A}$|density matrix (of a quantum system $A$)|\n",
    "|$\\mathcal{N}_{A\\rightarrow B}$|$\\mathcal{N}$, $\\mathcal{E}$|quantum channel (taking a quantum system $A$ to a quantum system $B$)|\n",
    "|$K_{i}$||Kraus operators of a quantum channel|\n",
    "|$\\mathrm{tr}$|$\\mathrm{tr}_{A}$|(partial) trace (on subsystem $A$)|\n",
    "| $\\mathcal{H}$     | $\\mathcal{H}_A$      | a Hilbert space (of quantum system $A$)   |\n",
    "|$\\mathcal{D}(\\mathcal{H})$|$\\mathcal{D}(\\mathcal{H}_{A})$|the set of density matrices on the Hilbert space $\\mathcal{H}$ (of quantum system $A$)|\n",
    "|$V$||isometric operator (or isometries)|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------VERSION---------\n",
      "quairkit: 0.3.0\n",
      "torch: 2.5.1+cpu\n",
      "numpy: 1.26.0\n",
      "scipy: 1.14.1\n",
      "matplotlib: 3.10.0\n",
      "---------SYSTEM---------\n",
      "Python version: 3.10.16\n",
      "OS: Windows\n",
      "OS version: 10.0.26100\n",
      "---------DEVICE---------\n",
      "CPU: ARMv8 (64-bit) Family 8 Model 1 Revision 201, Qualcomm Technologies Inc\n"
     ]
    }
   ],
   "source": [
    "qkit.print_info()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "quair_test",
   "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}