1.BasicGates/BasicGates.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic Gates Kata\n",
    "\n",
    "**Basic Gates** quantum kata is a series of exercises designed\n",
    "to get you familiar with the basic quantum gates in Q#.\n",
    "It covers the following topics:\n",
    "* basic single-qubit and multi-qubit gates,\n",
    "* adjoint and controlled gates,\n",
    "* using gates to modify the state of a qubit.\n",
    "\n",
    "Each task is wrapped in one operation preceded by the description of the task.\n",
    "Your goal is to fill in the blank (marked with `// ...` comments)\n",
    "with some Q# code that solves the task. To verify your answer, run the cell using Ctrl/⌘+Enter.\n",
    "\n",
    "Most tasks in this kata can be done using exactly one gate.\n",
    "None of the tasks require measurement, and the tests are written so as to fail if qubit state is measured.\n",
    "\n",
    "The tasks are given in approximate order of increasing difficulty; harder ones are marked with asterisks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To begin, first prepare this notebook for execution (if you skip this step, you'll get \"Syntax does not match any known patterns\" error when you try to execute Q# code in the next cells):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%package Microsoft.Quantum.Katas::0.9.1908.2906"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The package versions in the output of the cell above should always match. If you are running the Notebooks locally and the versions do not match, please install the IQ# version that matches the version of the `Microsoft.Quantum.Katas` package.\n",
    "> <details>\n",
    "> <summary><u>How to install the right IQ# version</u></summary>\n",
    "> For example, if the version of `Microsoft.Quantum.Katas` package above is 0.1.2.3, the installation steps are as follows:\n",
    ">\n",
    "> 1. Stop the kernel.\n",
    "> 2. Uninstall the existing version of IQ#:\n",
    ">        dotnet tool uninstall microsoft.quantum.iqsharp -g\n",
    "> 3. Install the matching version:\n",
    ">        dotnet tool install microsoft.quantum.iqsharp -g --version 0.1.2.3\n",
    "> 4. Reinstall the kernel:\n",
    ">        dotnet iqsharp install\n",
    "> 5. Restart the Notebook.\n",
    "> </details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part I. Single-Qubit Gates\n",
    "\n",
    "\n",
    "### Theory\n",
    "\n",
    "* A list of most common gates can be found in [this Wikipedia article](https://en.wikipedia.org/wiki/Quantum_logic_gate).\n",
    "* [Quirk](http://algassert.com/quirk) is a convenient tool for visualizing the effect of gates on qubit states.\n",
    "\n",
    "### Q# materials\n",
    "\n",
    "* Basic gates provided in Q# belong to the `Microsoft.Quantum.Intrinsic` namespace and are listed [here](https://docs.microsoft.com/qsharp/api/qsharp/microsoft.quantum.intrinsic).\n",
    "\n",
    "> Note that all operations in this section have `is Adj+Ctl` in their signature.\n",
    "This means that they should be implemented in a way that allows Q# \n",
    "to compute their adjoint and controlled variants automatically.\n",
    "Since each task is solved using only intrinsic gates, you should not need to put any special effort in this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.1. State flip: $|0\\rangle$ to $|1\\rangle$ and vice versa\n",
    "\n",
    "**Input:** A qubit in state $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$.\n",
    "\n",
    "**Goal:**  Change the state of the qubit to $\\alpha |1\\rangle + \\beta |0\\rangle$.\n",
    "\n",
    "**Example:**\n",
    "\n",
    "If the qubit is in state $|0\\rangle$, change its state to $|1\\rangle$.\n",
    "\n",
    "If the qubit is in state $|1\\rangle$, change its state to $|0\\rangle$.\n",
    "\n",
    "> Note that this operation is self-adjoint: applying it for a second time\n",
    "> returns the qubit to the original state. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T11_StateFlip_Test \n",
    "\n",
    "operation StateFlip (q : Qubit) : Unit is Adj+Ctl {\n",
    "    // The Pauli X gate will change the |0⟩ state to the |1⟩ state and vice versa.\n",
    "    // Type X(q);\n",
    "    // Then run the cell using Ctrl/⌘+Enter.\n",
    "\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.2. Basis change: $|0\\rangle$ to $|+\\rangle$ and $|1\\rangle$ to $|-\\rangle$ (and vice versa)\n",
    "\n",
    "**Input**: A qubit in state $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$.\n",
    "\n",
    "**Goal**:  Change the state of the qubit as follows:\n",
    "* If the qubit is in state $|0\\rangle$, change its state to $|+\\rangle = \\frac{1}{\\sqrt{2}} \\big(|0\\rangle + |1\\rangle\\big)$.\n",
    "* If the qubit is in state $|1\\rangle$, change its state to $|-\\rangle = \\frac{1}{\\sqrt{2}} \\big(|0\\rangle - |1\\rangle\\big)$.\n",
    "* If the qubit is in superposition, change its state according to the effect on basis vectors.\n",
    "\n",
    "> Note:  \n",
    "> $|+\\rangle$ and $|-\\rangle$ form a different basis for single-qubit states, called X basis.  \n",
    "> $|0\\rangle$ and $|1\\rangle$ are called Z basis.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T12_BasisChange_Test \n",
    "\n",
    "operation BasisChange (q : Qubit) : Unit is Adj+Ctl {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.3. Sign flip: $|+\\rangle$  to $|-\\rangle$  and vice versa.\n",
    "\n",
    "**Input**: A qubit in state $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$.\n",
    "\n",
    "**Goal** :  Change the qubit state to $\\alpha |0\\rangle - \\beta |1\\rangle$ (flip the sign of $|1\\rangle$ component of the superposition).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T13_SignFlip_Test \n",
    "\n",
    "operation SignFlip (q : Qubit) : Unit is Adj+Ctl {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.4. Amplitude change: $|0\\rangle$ to $\\cos{α} |0\\rangle + \\sin{α} |1\\rangle$.\n",
    "\n",
    "**Inputs:**\n",
    "\n",
    "1. Angle α, in radians, represented as Double.\n",
    "2. A qubit in state $|\\psi\\rangle = \\beta |0\\rangle + \\gamma |1\\rangle$.\n",
    "\n",
    "**Goal:**  Change the state of the qubit as follows:\n",
    "- If the qubit is in state $|0\\rangle$, change its state to $\\cos{α} |0\\rangle + \\sin{α} |1\\rangle$.\n",
    "- If the qubit is in state $|1\\rangle$, change its state to $-\\sin{α} |0\\rangle + \\cos{α} |1\\rangle$.\n",
    "- If the qubit is in superposition, change its state according to the effect on basis vectors.\n",
    "\n",
    "> This is the first operation in this kata that is not self-adjoint, i.e., applying it for a second time\n",
    "> does not return the qubit to the original state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T14_AmplitudeChange_Test\n",
    "\n",
    "operation AmplitudeChange (alpha : Double, q : Qubit) : Unit is Adj+Ctl {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.5. Phase flip\n",
    "\n",
    "**Input:** A qubit in state $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$.\n",
    "\n",
    "**Goal:** Change the qubit state to $\\alpha |0\\rangle + \\color{red}i\\beta |1\\rangle$ (add a relative phase $i$ to $|1\\rangle$ component of the superposition).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T15_PhaseFlip_Test\n",
    "\n",
    "operation PhaseFlip (q : Qubit) : Unit is Adj+Ctl {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.6. Phase change\n",
    "\n",
    "**Inputs:**\n",
    "\n",
    "1. Angle α, in radians, represented as Double.\n",
    "2. A qubit in state $|\\psi\\rangle = \\beta |0\\rangle + \\gamma |1\\rangle$.\n",
    "\n",
    "**Goal:**  Change the state of the qubit as follows:\n",
    "- If the qubit is in state $|0\\rangle$, don't change its state.\n",
    "- If the qubit is in state $|1\\rangle$, change its state to $e^{i\\alpha} |1\\rangle$.\n",
    "- If the qubit is in superposition, change its state according to the effect on basis vectors: $\\beta |0\\rangle + \\color{red}{e^{i\\alpha}} \\gamma |1\\rangle$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T16_PhaseChange_Test\n",
    "\n",
    "operation PhaseChange (alpha : Double, q : Qubit) : Unit is Adj+Ctl {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.7. Bell state change - 1\n",
    "\n",
    "**Input:** Two entangled qubits in Bell state $|\\Phi^{+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|00\\rangle + |11\\rangle\\big)$.\n",
    "\n",
    "**Goal:**  Change the two-qubit state to $|\\Phi^{-}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|00\\rangle - |11\\rangle\\big)$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T17_BellStateChange1_Test\n",
    "\n",
    "operation BellStateChange1 (qs : Qubit[]) : Unit is Adj+Ctl {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.8. Bell state change - 2\n",
    "\n",
    "**Input:** Two entangled qubits in Bell state $|\\Phi^{+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|00\\rangle + |11\\rangle\\big)$.\n",
    "\n",
    "**Goal:**  Change the two-qubit state to $|\\Psi^{+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|01\\rangle + |10\\rangle\\big)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T18_BellStateChange2_Test\n",
    "\n",
    "operation BellStateChange2 (qs : Qubit[]) : Unit is Adj+Ctl {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1.9. Bell state change - 3\n",
    "\n",
    "**Input:** Two entangled qubits in Bell state $|\\Phi^{+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|00\\rangle + |11\\rangle\\big)$.\n",
    "\n",
    "**Goal:**  Change the two-qubit state to $|\\Psi^{-}\\rangle = \\frac{1}{\\sqrt{2}} \\big(|01\\rangle - |10\\rangle\\big)$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T19_BellStateChange3_Test\n",
    "\n",
    "operation BellStateChange3 (qs : Qubit[]) : Unit is Adj+Ctl {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part II. Multi-Qubit Gates\n",
    "\n",
    "### Q# materials\n",
    "\n",
    "* Using controlled and adjoint versions of gates is covered in the Q# documentation on [operation types](https://docs.microsoft.com/quantum/language/type-model#operation-and-function-types)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 2.1. Two-qubit gate - 1\n",
    "\n",
    "**Input:** Two unentangled qubits (stored in an array of length 2).\n",
    "The first qubit will be in state $|\\psi\\rangle = \\alpha |0\\rangle + \\beta |1\\rangle$, the second - in state $|0\\rangle$\n",
    "(this can be written as two-qubit state  $\\big(\\alpha |0\\rangle + \\beta |1\\rangle \\big) \\otimes |0\\rangle = \\alpha |00\\rangle + \\beta |10\\rangle$.\n",
    "\n",
    "\n",
    "**Goal:**  Change the two-qubit state to $\\alpha |00\\rangle + \\beta |11\\rangle$.\n",
    "\n",
    "> Note that unless the starting state of the first qubit was $|0\\rangle$ or $|1\\rangle$,\n",
    "> the resulting two-qubit state can not be represented as a tensor product\n",
    "> of the states of individual qubits any longer; thus the qubits become entangled."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T21_TwoQubitGate1_Test\n",
    "\n",
    "operation TwoQubitGate1 (qs : Qubit[]) : Unit is Adj {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 2.2. Two-qubit gate - 2\n",
    "\n",
    "**Input:** Two unentangled qubits (stored in an array of length 2) in state $|+\\rangle \\otimes |+\\rangle = \\frac{1}{2} \\big( |00\\rangle + |01\\rangle + |10\\rangle \\color{blue}+ |11\\rangle \\big)$.\n",
    "\n",
    "\n",
    "**Goal:**  Change the two-qubit state to $\\frac{1}{2} \\big( |00\\rangle + |01\\rangle + |10\\rangle \\color{red}- |11\\rangle \\big)$.\n",
    "\n",
    "> Note that while the starting state can be represented as a tensor product of single-qubit states,\n",
    "> the resulting two-qubit state can not be represented in such a way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T22_TwoQubitGate2_Test\n",
    "\n",
    "operation TwoQubitGate2 (qs : Qubit[]) : Unit is Adj {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 2.3. Two-qubit gate - 3\n",
    "\n",
    "**Input:** Two unentangled qubits (stored in an array of length 2) in an arbitrary two-qubit state $\\alpha |00\\rangle + \\color{blue}\\beta |01\\rangle + \\color{blue}\\gamma |10\\rangle + \\delta |11\\rangle$.\n",
    "\n",
    "\n",
    "**Goal:**  Change the two-qubit state to $\\alpha |00\\rangle + \\color{red}\\gamma |01\\rangle + \\color{red}\\beta |10\\rangle + \\delta |11\\rangle$.\n",
    "\n",
    "> This task can be solved using one intrinsic gate; as an exercise, try to express the solution using several (possibly controlled) Pauli gates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T23_TwoQubitGate3_Test\n",
    "\n",
    "operation TwoQubitGate3 (qs : Qubit[]) : Unit is Adj {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 2.4. Toffoli gate\n",
    "\n",
    "**Input:** Three qubits (stored in an array of length 3) in an arbitrary three-qubit state \n",
    "$\\alpha |000\\rangle + \\beta |001\\rangle + \\gamma |010\\rangle + \\delta |011\\rangle + \\epsilon |100\\rangle + \\zeta|101\\rangle + \\color{blue}\\eta|110\\rangle + \\color{blue}\\theta|111\\rangle$.\n",
    "\n",
    "**Goal:** Flip the state of the third qubit if the state of the first two is $|11\\rangle$, i.e., change the three-qubit state to $\\alpha |000\\rangle + \\beta |001\\rangle + \\gamma |010\\rangle + \\delta |011\\rangle + \\epsilon |100\\rangle + \\zeta|101\\rangle + \\color{red}\\theta|110\\rangle + \\color{red}\\eta|111\\rangle$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T24_ToffoliGate_Test\n",
    "\n",
    "operation ToffoliGate (qs : Qubit[]) : Unit is Adj {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 2.5. Fredkin gate\n",
    "\n",
    "**Input:** Three qubits (stored in an array of length 3) in an arbitrary three-qubit state \n",
    "$\\alpha |000\\rangle + \\beta |001\\rangle + \\gamma |010\\rangle + \\delta |011\\rangle + \\epsilon |100\\rangle + \\color{blue}\\zeta|101\\rangle + \\color{blue}\\eta|110\\rangle + \\theta|111\\rangle$.\n",
    "\n",
    "**Goal:** Swap the states of second and third qubit if and only if the state of the first qubit is $|1\\rangle$, i.e., change the three-qubit state to $\\alpha |000\\rangle + \\beta |001\\rangle + \\gamma |010\\rangle + \\delta |011\\rangle + \\epsilon |100\\rangle + \\color{red}\\eta|101\\rangle + \\color{red}\\zeta|110\\rangle + \\theta|111\\rangle$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T25_FredkinGate_Test\n",
    "\n",
    "operation FredkinGate (qs : Qubit[]) : Unit is Adj {\n",
    "    // ...\n",
    "}"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Q#",
   "language": "qsharp",
   "name": "iqsharp"
  },
  "language_info": {
   "file_extension": ".qs",
   "mimetype": "text/x-qsharp",
   "name": "qsharp",
   "version": "0.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}