QuanTorch_final.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import QuanTorch as qtorch\n",
    "import QuanTorch.basis as qbasis\n",
    "import QuanTorch.operations as qoperations\n",
    "import QuanTorch.checkers as qcheckers\n",
    "import QuanTorch.helpers as qhelpers\n",
    "import QuanTorch.gates as qgates\n",
    "from QuanTorch.states import qstate, density_matrix\n",
    "\n",
    "from math import *\n",
    "import inspect\n",
    "from IPython.display import display, Math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.7071+0.j],\n",
       "        [ 0.7071+0.j]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plus = qbasis.plus\n",
    "result = qgates.X(qgates.Z(plus))\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Index:\n",
    "- [Dirac Notation](#dirac)\n",
    "    - [Basis Vectors & States](#basis)\n",
    "    - [Basic Operations](#operations)\n",
    "    - [Checkers](#checkers)\n",
    "    - [Density Matrix](#dmatrix)\n",
    "    - [Finding Probabilities](#probs)\n",
    "- [Quantum Gates](#gates)\n",
    "    - [Check if gates are unitary](#unitary)\n",
    "    - [Single Qubit Gates](#single)\n",
    "    - [Multi Qubit Gates](#multi)\n",
    "    - <strike> [Visualization](#Vis)</strike> (#TODO)\n",
    "- <strike> [Quantum Circuits](#circuits)</strike> (#TODO)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dirac Notation\n",
    "<a id='dirac'></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Dirac image](assets/dirac.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basis Vectors & States\n",
    "<a id='basis'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zero: tensor([[1.+0.j],\n",
      "        [0.+0.j]])\n",
      "--------------------------------------------------\n",
      "Notice that it's a column vector: Shape is:\n",
      " torch.Size([2, 1])\n",
      "--------------------------------------------------\n",
      "The default data type supports complex numbers: Data type is:\n",
      " torch.complex64\n",
      "--------------------------------------------------\n",
      "Similarly, one: tensor([[0.+0.j],\n",
      "        [1.+0.j]])\n",
      "\n",
      " plus: tensor([[0.7071+0.j],\n",
      "        [0.7071+0.j]])\n",
      "\n",
      " minus: tensor([[ 0.7071+0.j],\n",
      "        [-0.7071+0.j]])\n"
     ]
    }
   ],
   "source": [
    "zero = qbasis.zero\n",
    "print(f\"zero: {zero}\", end=\"\\n\" + \"-\" * 50 + \"\\n\")\n",
    "print(\n",
    "    f\"Notice that it's a column vector: Shape is:\\n {zero.shape}\",\n",
    "    end=\"\\n\" + \"-\" * 50 + \"\\n\",\n",
    ")\n",
    "print(\n",
    "    f\"The default data type supports complex numbers: Data type is:\\n {zero.dtype}\",\n",
    "    end=\"\\n\" + \"-\" * 50 + \"\\n\",\n",
    ")\n",
    "print(\n",
    "    f\"Similarly, one: {qbasis.one}\\n\\n plus: {qbasis.plus}\\n\\n minus: {qbasis.minus}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Operations\n",
    "<a id='basis'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Supported operations:\n",
      "- inner_product\n",
      "- outer_product\n",
      "- tensor_product\n"
     ]
    }
   ],
   "source": [
    "print(\"Supported operations:\")\n",
    "operations = [o[0] for o in inspect.getmembers(\n",
    "    qoperations) if inspect.isfunction(o[1])]\n",
    "for operation in operations:\n",
    "    print(f\"- {operation}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner product:\n",
      "\n",
      "< 0 | 0 >:\n",
      " tensor([[1.+0.j]])\n",
      "< 0 | 1 >:\n",
      " tensor([[0.+0.j]])\n",
      "< + | - >:\n",
      " tensor([[0.+0.j]])\n",
      "< + | 0 >:\n",
      " tensor([[0.7071+0.j]])\n"
     ]
    }
   ],
   "source": [
    "# inner product\n",
    "print(\"inner product:\\n\")\n",
    "print(f\"< 0 | 0 >:\\n {qoperations.inner_product(qbasis.zero, qbasis.zero)}\")\n",
    "print(f\"< 0 | 1 >:\\n {qoperations.inner_product(qbasis.zero, qbasis.one)}\")\n",
    "print(f\"< + | - >:\\n {qoperations.inner_product(qbasis.plus, qbasis.minus)}\")\n",
    "print(f\"< + | 0 >:\\n {qoperations.inner_product(qbasis.plus, qbasis.zero)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "outer product:\n",
      "\n",
      "| 0 >< 0 |:\n",
      " tensor([[1.+0.j, 0.+0.j],\n",
      "        [0.+0.j, 0.+0.j]])\n",
      "| 0 >< 1 |:\n",
      " tensor([[0.+0.j, 1.+0.j],\n",
      "        [0.+0.j, 0.+0.j]])\n",
      "| + >< - |:\n",
      " tensor([[ 0.5000+0.j, -0.5000-0.j],\n",
      "        [ 0.5000+0.j, -0.5000-0.j]])\n",
      "| + >< 0 |:\n",
      " tensor([[0.7071+0.j, 0.0000+0.j],\n",
      "        [0.7071+0.j, 0.0000+0.j]])\n"
     ]
    }
   ],
   "source": [
    "# outer product\n",
    "print(\"\\nouter product:\\n\")\n",
    "print(f\"| 0 >< 0 |:\\n {qoperations.outer_product(qbasis.zero, qbasis.zero)}\")\n",
    "print(f\"| 0 >< 1 |:\\n {qoperations.outer_product(qbasis.zero, qbasis.one)}\")\n",
    "print(f\"| + >< - |:\\n {qoperations.outer_product(qbasis.plus, qbasis.minus)}\")\n",
    "print(f\"| + >< 0 |:\\n {qoperations.outer_product(qbasis.plus, qbasis.zero)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor product:\n",
      "\n",
      "| 0 0 > = :\n",
      " tensor([[1.+0.j],\n",
      "        [0.+0.j],\n",
      "        [0.+0.j],\n",
      "        [0.+0.j]])\n",
      "Shape is torch.Size([4, 1])\n",
      "| 0 1 > = :\n",
      " tensor([[0.+0.j],\n",
      "        [1.+0.j],\n",
      "        [0.+0.j],\n",
      "        [0.+0.j]])\n",
      "Shape is torch.Size([4, 1])\n",
      "| + - > = :\n",
      " tensor([[ 0.5000+0.j],\n",
      "        [-0.5000+0.j],\n",
      "        [ 0.5000+0.j],\n",
      "        [-0.5000+0.j]])\n",
      "Shape is torch.Size([4, 1])\n"
     ]
    }
   ],
   "source": [
    "# tensor product\n",
    "print(\"tensor product:\\n\")\n",
    "\n",
    "print(f\"| 0 0 > = :\\n {qoperations.tensor_product(qbasis.zero, qbasis.zero)}\")\n",
    "print(f\"Shape is {qoperations.tensor_product(qbasis.zero, qbasis.zero).shape}\")\n",
    "\n",
    "print(f\"| 0 1 > = :\\n {qoperations.tensor_product(qbasis.zero, qbasis.one)}\")\n",
    "print(f\"Shape is {qoperations.tensor_product(qbasis.zero, qbasis.one).shape}\")\n",
    "\n",
    "print(f\"| + - > = :\\n {qoperations.tensor_product(qbasis.plus, qbasis.minus)}\")\n",
    "print(f\"Shape is {qoperations.tensor_product(qbasis.plus, qbasis.minus).shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Checkers\n",
    "<a id='checkers'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Supported checkers:\n",
      "- check_basis\n",
      "- check_normalized\n",
      "- check_orthogonal\n",
      "- check_qubit\n",
      "- check_unitary\n",
      "- check_valid_density_matrix\n",
      "- positive_operator\n"
     ]
    }
   ],
   "source": [
    "print(\"Supported checkers:\")\n",
    "checkers = [o[0] for o in inspect.getmembers(\n",
    "    qcheckers) if inspect.isfunction(o[1])]\n",
    "for checker in checkers:\n",
    "    if checker not in operations:\n",
    "        print(f\"- {checker}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Check orthogonality:\n",
      "\n",
      "Check if | 0 > and | 1 > are orthogonal: True\n",
      "Check if | 0 > and | + > are orthogonal: False\n",
      "Check if | 0 > and | - > are orthogonal: False\n",
      "Check if | - > and | + > are orthogonal: True\n"
     ]
    }
   ],
   "source": [
    "# check normalizedity\n",
    "print(\"Check orthogonality:\\n\")\n",
    "print(\n",
    "    f\"Check if | 0 > and | 1 > are orthogonal: {qcheckers.check_orthogonal([qbasis.zero, qbasis.one])}\"\n",
    ")\n",
    "print(\n",
    "    f\"Check if | 0 > and | + > are orthogonal: {qcheckers.check_orthogonal([qbasis.zero, qbasis.plus])}\"\n",
    ")\n",
    "print(\n",
    "    f\"Check if | 0 > and | - > are orthogonal: {qcheckers.check_orthogonal([qbasis.zero, qbasis.minus])}\"\n",
    ")\n",
    "print(\n",
    "    f\"Check if | - > and | + > are orthogonal: {qcheckers.check_orthogonal([qbasis.minus, qbasis.plus])}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Check normality:\n",
      "\n",
      "Check if | 0 > is normalized: True\n",
      "Check if [-1, 3i, i] is normalized: False\n",
      "Check if | Ψ + > is normalized: True\n"
     ]
    }
   ],
   "source": [
    "# check normality\n",
    "print(\"Check normality:\\n\")\n",
    "print(\n",
    "    f\"Check if | 0 > is normalized: {qcheckers.check_normalized(qbasis.zero)}\")\n",
    "print(\n",
    "    f\"Check if [-1, 3i, i] is normalized: {qcheckers.check_normalized(qstate([-1, 3j, 1j]))}\"\n",
    ")\n",
    "# Sheet 1 | Q3\n",
    "print(\n",
    "    f\"Check if | Ψ + > is normalized: {qcheckers.check_normalized(qstate([0, 1 / sqrt(2), 1 / sqrt(2), 0]))}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Check basis (orthonormality):\n",
      "\n",
      "Check if | 0 > and | 1 > are valis basis: True\n",
      "Check if | + > and | - > are valis basis: True\n",
      "Check if [1, 0, 0] and [0, 1, 0] and [0, 0, 1] are valis basis: True\n"
     ]
    }
   ],
   "source": [
    "# Check basis\n",
    "# Sheet 1 | Q1\n",
    "print(\"Check basis (orthonormality):\\n\")\n",
    "print(\n",
    "    f\"Check if | 0 > and | 1 > are valis basis: {qcheckers.check_basis([qbasis.zero, qbasis.one])}\"\n",
    ")\n",
    "print(\n",
    "    f\"Check if | + > and | - > are valis basis: {qcheckers.check_basis([qbasis.plus, qbasis.minus])}\"\n",
    ")\n",
    "print(\n",
    "    f\"Check if [1, 0, 0] and [0, 1, 0] and [0, 0, 1] are valis basis: {qcheckers.check_basis([qstate([1, 0, 0]), qstate([0, 1, 0]), qstate([0, 0, 1])])}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vectors are orthogonal: True | Vectors are normalized: False\n",
      "Check if [0, 0.5] and [0.5, 0] are valis basis: False\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    f\"Check if [0, 0.5] and [0.5, 0] are valis basis: {qcheckers.check_basis([qstate([0, 0.5]), qstate([0.5, 0])], verbose = True)}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Check \\ if \\ | \\Psi \\rangle = \\frac{1}{\\sqrt{2}} [1, 1, 1, 1] \\ is \\ a \\ qubit$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(\n",
    "    Math(\n",
    "        r\"Check \\ if \\ | \\Psi \\rangle = \\frac{1}{\\sqrt{2}} [1, 1, 1, 1] \\ is \\ a \\ qubit\"\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Check qubit:\n",
      "\n",
      "Check if | 0 > is a qubit: True\n",
      "Check if | Ψ - > is a qubit: True\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Check \\ if \\ | \\Psi \\rangle = \\frac{1}{\\sqrt{2}} [1, 1, 1, 1] \\ is \\ a \\ qubit$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Check \\ if \\ | \\Phi \\rangle = \\frac{1}{2} |00 \\rangle + \\frac{1}{2} |01 \\rangle + \\frac{1}{2} |10 \\rangle + \\frac{1}{2} |11 \\rangle \\ is \\ a \\ qubit$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Check qubit\n",
    "print(\"Check qubit:\\n\")\n",
    "print(f\"Check if | 0 > is a qubit: {qcheckers.check_qubit(qbasis.zero)}\")\n",
    "print(\n",
    "    f\"Check if | Ψ - > is a qubit: {qcheckers.check_qubit(qstate([0, 1 / sqrt(2), -1 / sqrt(2), 0]))}\"\n",
    ")\n",
    "\n",
    "# Sheet 1 | Q2\n",
    "display(\n",
    "    Math(\n",
    "        r\"Check \\ if \\ | \\Psi \\rangle = \\frac{1}{\\sqrt{2}} [1, 1, 1, 1] \\ is \\ a \\ qubit\"\n",
    "    )\n",
    ")\n",
    "print(\n",
    "    qcheckers.check_qubit(qstate([1 / sqrt(2), 1 / sqrt(2), 1 / sqrt(2), 1 / sqrt(2)]))\n",
    ")\n",
    "\n",
    "display(\n",
    "    Math(\n",
    "        r\"Check \\ if \\ | \\Phi \\rangle = \\frac{1}{2} |00 \\rangle + \\frac{1}{2} |01 \\rangle + \\frac{1}{2} |10 \\rangle + \\frac{1}{2} |11 \\rangle \\ is \\ a \\ qubit\"\n",
    "    )\n",
    ")\n",
    "print(qcheckers.check_qubit(qstate([1 / 2, 1 / 2, 1 / 2, 1 / 2])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Density Matrix\n",
    "<a id='dmatrix'></a>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0.3333+0.0000j, 0.0000+0.3333j])\n",
      "tensor([-0.0000-0.3333j, 0.6667+0.0000j])\n",
      "Valid density matrix: True\n",
      "Type: State is mixed\n"
     ]
    }
   ],
   "source": [
    "# Valid Density Matrix\n",
    "P = density_matrix([[1 / 3, 1.0j / 3], [-1.0j / 3, 2 / 3]])\n",
    "# print this 2x2 matrix in a nice way\n",
    "for row in P:\n",
    "    print(row)\n",
    "\n",
    "print(f\"Valid density matrix: {qcheckers.check_valid_density_matrix(P)}\")\n",
    "print(f\"Type: {qhelpers.determine_state(P)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0.5000+0.j, 0.0000+0.j])\n",
      "tensor([0.0000+0.j, 0.5000+0.j])\n",
      "Valid density matrix: True\n",
      "Type: State is completely mixed\n"
     ]
    }
   ],
   "source": [
    "# Valid Density Matrix\n",
    "P = density_matrix([[1 / 2, 0], [0, 1 / 2]])\n",
    "# print this 2x2 matrix in a nice way\n",
    "for row in P:\n",
    "    print(row)\n",
    "\n",
    "print(f\"Valid density matrix: {qcheckers.check_valid_density_matrix(P)}\")\n",
    "print(f\"Type: {qhelpers.determine_state(P)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0.5000+0.0000j, -0.0000-0.2000j])\n",
      "tensor([0.0000+0.j, 0.5000+0.j])\n",
      "Valid density matrix: False\n",
      "Matrix is not Hermitian\n",
      "Type: Invalid density matrix\n"
     ]
    }
   ],
   "source": [
    "# Valid Density Matrix\n",
    "P = density_matrix([[1 / 2, -1.0j / 5], [0, 1 / 2]])\n",
    "# print this 2x2 matrix in a nice way\n",
    "for row in P:\n",
    "    print(row)\n",
    "\n",
    "print(f\"Valid density matrix: {qcheckers.check_valid_density_matrix(P)}\")\n",
    "print(f\"Type: {qhelpers.determine_state(P, verbose=True)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Finding Probability\n",
    "<a id='probs'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle | \\psi \\rangle = \\frac{1}{\\sqrt{3}} |0\\rangle + \\sqrt{\\frac{2}{3}} |1\\rangle$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability of finding | 0 > is 0.33\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle | \\psi \\rangle = \\frac{1+i}{\\sqrt{3}} |0\\rangle - \\frac{i}{\\sqrt{3}} |1\\rangle$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability of finding | 0 > is 0.67\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle | \\psi \\rangle = \\frac{1}{2} |0\\rangle + \\frac{\\sqrt{3}}{2} |1\\rangle$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability of finding | + > is 0.93\n"
     ]
    }
   ],
   "source": [
    "# Sheet 1 | Q 4\n",
    "\n",
    "# |𝜓〉=1√3|0〉+ √23|1〉\n",
    "display(\n",
    "    Math(\n",
    "        r\"| \\psi \\rangle = \\frac{1}{\\sqrt{3}} |0\\rangle + \\sqrt{\\frac{2}{3}} |1\\rangle\"\n",
    "    )\n",
    ")\n",
    "psi = qstate([1 / sqrt(3), sqrt(2 / 3)])\n",
    "print(\n",
    "    f\"Probability of finding | 0 > is {qhelpers.find_probability(psi, qbasis.zero):.2f}\"\n",
    ")\n",
    "\n",
    "# # |𝜓〉=(1+𝑖) / √3|0〉 − 𝑖 / √3|1〉\n",
    "display(\n",
    "    Math(\n",
    "        r\"| \\psi \\rangle = \\frac{1+i}{\\sqrt{3}} |0\\rangle - \\frac{i}{\\sqrt{3}} |1\\rangle\"\n",
    "    )\n",
    ")\n",
    "psi = qstate([(1 + 1j) / sqrt(3), (-1j / sqrt(3))])\n",
    "print(\n",
    "    f\"Probability of finding | 0 > is {qhelpers.find_probability(psi, qbasis.zero):.2f}\"\n",
    ")\n",
    "\n",
    "# Sheet 1 | Q5\n",
    "# |𝜓〉 = 1/2|0〉+ √3 / 2|1〉\n",
    "display(Math(r\"| \\psi \\rangle = \\frac{1}{2} |0\\rangle + \\frac{\\sqrt{3}}{2} |1\\rangle\"))\n",
    "psi = qstate([1 / 2, sqrt(3) / 2])\n",
    "print(\n",
    "    f\"Probability of finding | + > is {qhelpers.find_probability(psi, qbasis.plus):.2f}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantum Gates\n",
    "<a id='gates'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Qgates image](assets/qgates.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check if the gates are unitary\n",
    "<a id =\"unitary\"><a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Check if X Pauli gate is unitary: True\n",
      "Check if H Hadamard gate is unitary: True\n",
      "Check if CNOT gate is unitary: True\n",
      "Check if A is unitary: False\n"
     ]
    }
   ],
   "source": [
    "X = qgates.X(None, gate_matrix=True)\n",
    "print(f\"Check if X Pauli gate is unitary: {qcheckers.check_unitary(X)}\")\n",
    "\n",
    "H = qgates.H(None, gate_matrix=True)\n",
    "print(f\"Check if H Hadamard gate is unitary: {qcheckers.check_unitary(H)}\")\n",
    "\n",
    "CNOT = qgates.CNOT(None, None, gate_matrix=True)\n",
    "print(f\"Check if CNOT gate is unitary: {qcheckers.check_unitary(CNOT)}\")\n",
    "\n",
    "# Define any arbitrary non-unitary matrix\n",
    "A = qstate([[1, 2], [3, 4]])\n",
    "print(f\"Check if A is unitary: {qcheckers.check_unitary(A)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Single Qubit Gates\n",
    "<a id=\"single\"><a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X Pauli Gate:\n",
      "\n",
      "X | 0 >:\n",
      "gtensor([[0.+0.j],\n",
      "        [1.+0.j]])\n",
      "X | 1 >:\n",
      "gtensor([[1.+0.j],\n",
      "        [0.+0.j]])\n",
      "X | + >:\n",
      "gtensor([[0.7071+0.j],\n",
      "        [0.7071+0.j]])\n",
      "Z Pauli Gate:\n",
      "\n",
      "Z | 0 >:\n",
      "gtensor([[1.+0.j],\n",
      "        [0.+0.j]])\n",
      "Z | 1 >:\n",
      "gtensor([[ 0.+0.j],\n",
      "        [-1.+0.j]])\n",
      "Z | + >:\n",
      "gtensor([[ 0.7071+0.j],\n",
      "        [-0.7071+0.j]])\n"
     ]
    }
   ],
   "source": [
    "# X Pauli Gate\n",
    "print(\"X Pauli Gate:\\n\")\n",
    "print(f\"X | 0 >:\\ng{qgates.X(qbasis.zero)}\")\n",
    "print(f\"X | 1 >:\\ng{qgates.X(qbasis.one)}\")\n",
    "print(f\"X | + >:\\ng{qgates.X(qbasis.plus)}\")\n",
    "\n",
    "# Z Pauli Gate\n",
    "print(\"Z Pauli Gate:\\n\")\n",
    "print(f\"Z | 0 >:\\ng{qgates.Z(qbasis.zero)}\")\n",
    "print(f\"Z | 1 >:\\ng{qgates.Z(qbasis.one)}\")\n",
    "print(f\"Z | + >:\\ng{qgates.Z(qbasis.plus)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Y Pauli Gate:\n",
      "\n",
      "Y | 0 >:\n",
      "gtensor([[0.+0.j],\n",
      "        [0.+1.j]])\n",
      "Y | 1 >:\n",
      "gtensor([[0.-1.j],\n",
      "        [0.+0.j]])\n",
      "Hadamard Gate:\n",
      "\n",
      "H | 0 >:\n",
      "gtensor([[0.7071+0.j],\n",
      "        [0.7071+0.j]])\n",
      "H | 1 >:\n",
      "gtensor([[ 0.7071+0.j],\n",
      "        [-0.7071+0.j]])\n",
      "H | + >:\n",
      "gtensor([[1.0000+0.j],\n",
      "        [0.0000+0.j]])\n",
      "H | - >:\n",
      "gtensor([[0.0000+0.j],\n",
      "        [1.0000+0.j]])\n"
     ]
    }
   ],
   "source": [
    "# Y Pauli Gate\n",
    "print(\"Y Pauli Gate:\\n\")\n",
    "print(f\"Y | 0 >:\\ng{qgates.Y(qbasis.zero)}\")\n",
    "print(f\"Y | 1 >:\\ng{qgates.Y(qbasis.one)}\")\n",
    "\n",
    "# Hadamard Gate\n",
    "print(\"Hadamard Gate:\\n\")\n",
    "print(f\"H | 0 >:\\ng{qgates.H(qbasis.zero)}\")\n",
    "print(f\"H | 1 >:\\ng{qgates.H(qbasis.one)}\")\n",
    "print(f\"H | + >:\\ng{qgates.H(qbasis.plus)}\")\n",
    "print(f\"H | - >:\\ng{qgates.H(qbasis.minus)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi Qubit Gates\n",
    "<a id = \"multi\"><a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CNOT Gate:\n",
      "\n",
      "CNOT | 0 0 >:\n",
      "gtensor([[1.+0.j],\n",
      "        [0.+0.j],\n",
      "        [0.+0.j],\n",
      "        [0.+0.j]])\n",
      "CNOT | 0 1 >:\n",
      "gtensor([[0.+0.j],\n",
      "        [1.+0.j],\n",
      "        [0.+0.j],\n",
      "        [0.+0.j]])\n",
      "CNOT | 1 1 >:\n",
      "gtensor([[0.+0.j],\n",
      "        [0.+0.j],\n",
      "        [1.+0.j],\n",
      "        [0.+0.j]])\n"
     ]
    }
   ],
   "source": [
    "print(\"CNOT Gate:\\n\")\n",
    "print(f\"CNOT | 0 0 >:\\ng{qgates.CNOT(qbasis.zero, qbasis.zero)}\")\n",
    "print(f\"CNOT | 0 1 >:\\ng{qgates.CNOT(qbasis.zero, qbasis.one)}\")\n",
    "print(f\"CNOT | 1 1 >:\\ng{qgates.CNOT(qbasis.one, qbasis.one)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bell State Gate\n",
      "\n",
      "H | 0 0 >: (should be | Φ + >):\n",
      "tensor([[0.7071+0.j],\n",
      "        [0.0000+0.j],\n",
      "        [0.0000+0.j],\n",
      "        [0.7071+0.j]])\n",
      "H | 0 1 >: (should be | Ψ + >:\n",
      "tensor([[0.0000+0.j],\n",
      "        [0.7071+0.j],\n",
      "        [0.7071+0.j],\n",
      "        [0.0000+0.j]])\n",
      "H | 1 0 >: (should be | Φ - >):\n",
      "tensor([[ 0.7071+0.j],\n",
      "        [ 0.0000+0.j],\n",
      "        [ 0.0000+0.j],\n",
      "        [-0.7071+0.j]])\n",
      "H | 1 1 >: (should be | Ψ - >):\n",
      "tensor([[ 0.0000+0.j],\n",
      "        [ 0.7071+0.j],\n",
      "        [-0.7071+0.j],\n",
      "        [ 0.0000+0.j]])\n"
     ]
    }
   ],
   "source": [
    "print(\"Bell State Gate\\n\")\n",
    "print(\n",
    "    f\"H | 0 0 >: (should be | Φ + >):\\n{qgates.BellStateGate(qbasis.zero, qbasis.zero)}\"\n",
    ")\n",
    "print(\n",
    "    f\"H | 0 1 >: (should be | Ψ + >:\\n{qgates.BellStateGate(qbasis.zero, qbasis.one)}\"\n",
    ")\n",
    "print(\n",
    "    f\"H | 1 0 >: (should be | Φ - >):\\n{qgates.BellStateGate(qbasis.one, qbasis.zero)}\"\n",
    ")\n",
    "print(\n",
    "    f\"H | 1 1 >: (should be | Ψ - >):\\n{qgates.BellStateGate(qbasis.one, qbasis.one)}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ctrl Hadamard\n",
      "\n",
      "H | 0 0 >:\n",
      "tensor([[1.+0.j],\n",
      "        [0.+0.j],\n",
      "        [0.+0.j],\n",
      "        [0.+0.j]])\n",
      "H | 0 1 >:\n",
      "tensor([[0.+0.j],\n",
      "        [1.+0.j],\n",
      "        [0.+0.j],\n",
      "        [0.+0.j]])\n",
      "H | 1 0 >:\n",
      "tensor([[0.0000+0.j],\n",
      "        [0.0000+0.j],\n",
      "        [0.7071+0.j],\n",
      "        [0.7071+0.j]])\n",
      "H | 1 1 >:\n",
      "tensor([[ 0.0000+0.j],\n",
      "        [ 0.0000+0.j],\n",
      "        [ 0.7071+0.j],\n",
      "        [-0.7071+0.j]])\n"
     ]
    }
   ],
   "source": [
    "print(\"Ctrl Hadamard\\n\")\n",
    "print(f\"H | 0 0 >:\\n{qgates.Ctrl_Hadamard(qbasis.zero, qbasis.zero)}\")\n",
    "print(f\"H | 0 1 >:\\n{qgates.Ctrl_Hadamard(qbasis.zero, qbasis.one)}\")\n",
    "print(f\"H | 1 0 >:\\n{qgates.Ctrl_Hadamard(qbasis.one, qbasis.zero)}\")\n",
    "print(f\"H | 1 1 >:\\n{qgates.Ctrl_Hadamard(qbasis.one, qbasis.one)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Swap Gate\n",
      "\n",
      "Swap | 0 0 >:\n",
      "tensor([[1.+0.j],\n",
      "        [0.+0.j],\n",
      "        [0.+0.j],\n",
      "        [0.+0.j]])\n",
      "Swap | 0 1 >:\n",
      "tensor([[0.+0.j],\n",
      "        [0.+0.j],\n",
      "        [1.+0.j],\n",
      "        [0.+0.j]])\n",
      "Swap | + 0 >:\n",
      "(tensor([[1.+0.j],\n",
      "        [0.+0.j]]), tensor([[0.7071+0.j],\n",
      "        [0.7071+0.j]]))\n",
      "Swap | 0 + >:\n",
      "tensor([[0.7071+0.j],\n",
      "        [0.0000+0.j],\n",
      "        [0.7071+0.j],\n",
      "        [0.0000+0.j]])\n"
     ]
    }
   ],
   "source": [
    "print(\"Swap Gate\\n\")\n",
    "print(f\"Swap | 0 0 >:\\n{qgates.swap_gate(qbasis.zero, qbasis.zero)}\")\n",
    "print(f\"Swap | 0 1 >:\\n{qgates.swap_gate(qbasis.zero, qbasis.one)}\")\n",
    "print(\n",
    "    f\"Swap | + 0 >:\\n{qgates.swap_gate(qbasis.plus, qbasis.zero, format = 'ketbra')}\")\n",
    "print(f\"Swap | 0 + >:\\n{qgates.swap_gate(qbasis.zero, qbasis.plus)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ctrl Swap Gate\n",
      "\n",
      "Swap | 0 0 0 >:\n",
      "tensor([[0.+0.j],\n",
      "        [1.+0.j],\n",
      "        [0.+0.j],\n",
      "        [0.+0.j]])\n",
      "Swap | 0 0 1 >:\n",
      "tensor([[0.+0.j],\n",
      "        [0.+0.j],\n",
      "        [1.+0.j],\n",
      "        [0.+0.j]])\n"
     ]
    }
   ],
   "source": [
    "print(\"Ctrl Swap Gate\\n\")\n",
    "print(\n",
    "    f\"Swap | 0 0 0 >:\\n{qgates.Ctrl_Swap(qbasis.zero, qbasis.zero, qbasis.one)}\")\n",
    "print(\n",
    "    f\"Swap | 0 0 1 >:\\n{qgates.Ctrl_Swap(qbasis.one, qbasis.zero, qbasis.one)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Toffoli Gate\n",
      "\n",
      "Toffoli(1, 0, 0) (# should be | 0 >):\n",
      "tensor([[1.+0.j],\n",
      "        [0.+0.j]])\n",
      "Toffoli(1, 1, 0) (# should be | 1 >):\n",
      "tensor([[0.+0.j],\n",
      "        [1.+0.j]])\n",
      "Toffoli(0, 1, 1) (# should be | 1 >):\n",
      "tensor([[0.+0.j],\n",
      "        [1.+0.j]])\n"
     ]
    }
   ],
   "source": [
    "print(\"Toffoli Gate\\n\")\n",
    "print(\n",
    "    f\"Toffoli(1, 0, 0) (# should be | 0 >):\\n{qgates.Toffoli(qbasis.one, qbasis.zero, qbasis.zero)}\"\n",
    ")\n",
    "print(\n",
    "    f\"Toffoli(1, 1, 0) (# should be | 1 >):\\n{qgates.Toffoli(qbasis.one, qbasis.one, qbasis.zero)}\"\n",
    ")\n",
    "print(\n",
    "    f\"Toffoli(0, 1, 1) (# should be | 1 >):\\n{qgates.Toffoli(qbasis.zero, qbasis.one, qbasis.one)}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " | 0 > AND | 0 > :\n",
      "tensor([[1.+0.j],\n",
      "        [0.+0.j]])\n",
      " | 0 > AND | 1 > :\n",
      "tensor([[1.+0.j],\n",
      "        [0.+0.j]])\n",
      " | 1 > AND | 0 > :\n",
      "tensor([[1.+0.j],\n",
      "        [0.+0.j]])\n",
      " | 1 > AND | 1 > :\n",
      "tensor([[0.+0.j],\n",
      "        [1.+0.j]])\n",
      "--------------------------------------------------\n",
      "NOT | 0 > :\n",
      "tensor([[1.+0.j],\n",
      "        [0.+0.j]])\n",
      "NOT | 1 > :\n",
      "tensor([[0.+0.j],\n",
      "        [1.+0.j]])\n"
     ]
    }
   ],
   "source": [
    "# Building AND uising Tofooli (Sheet 3 | Q1)\n",
    "c = qbasis.zero\n",
    "print(f\" | 0 > AND | 0 > :\\n{qgates.Toffoli(qbasis.zero, qbasis.zero,c)}\")\n",
    "print(f\" | 0 > AND | 1 > :\\n{qgates.Toffoli(qbasis.zero, qbasis.one,c)}\")\n",
    "print(f\" | 1 > AND | 0 > :\\n{qgates.Toffoli(qbasis.one, qbasis.zero,c)}\")\n",
    "print(f\" | 1 > AND | 1 > :\\n{qgates.Toffoli(qbasis.one, qbasis.one,c)}\")\n",
    "\n",
    "# Building NOT uising Tofooli (Sheet 3 | Q2)\n",
    "b = qbasis.one\n",
    "c = qbasis.zero\n",
    "\n",
    "print(\"-\" * 50)\n",
    "print(f\"NOT | 0 > :\\n{qgates.Toffoli(qbasis.zero, b, c)}\")\n",
    "print(f\"NOT | 1 > :\\n{qgates.Toffoli(qbasis.one, b, c)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# External Links"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [ML4SCI QML Tutorials](https://github.com/ML4SCI/QML-hands-on/tree/main/notebooks)\n",
    "- [PennyLane (Quantum Machine Learning Library)](https://pennylane.ai/)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "main",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}