tutorials/MultiQubitSystems/MultiQubitSystems.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multi-Qubit Systems\n",
    "\n",
    "This tutorial introduces you to multi-qubit systems - their representation in mathematical notation and in Q# code, and the concept of entanglement.\n",
    "\n",
    "If you are not familiar with the [single-qubit systems](../Qubit/Qubit.ipynb), we recommend that you complete that tutorial first.\n",
    "\n",
    "This tutorial covers the following topics:\n",
    "* Vector representation of multi-qubit systems\n",
    "* Entangled and separable states\n",
    "* Dirac notation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multi-Qubit Systems\n",
    "\n",
    "In the previous tutorial we discussed the concept of a qubit - the basic building block of a quantum computer. \n",
    "A multi-qubit system is a collection of multiple qubits, treated as a single system.\n",
    "\n",
    "Let's start by examining a system of two classical bits. Each bit can be in two states: $0$ and $1$. Therefore, a system of two bits can be in four different states: $00$, $01$, $10$, and $11$. Generally, a system of $N$ classical bits can be in any of the $2^N$ states.\n",
    "\n",
    "A system of $N$ qubits can also be in any of the $2^N$ classical states, but, unlike the classical bits, it can also be in a **superposition** of all these states.\n",
    "\n",
    "Similarly to single-qubit systems, a state of an $N$-qubit system can be represented as a complex vector of size $2^N$:\n",
    "$$\\begin{bmatrix} x_0 \\\\ x_1 \\\\ \\vdots \\\\ x_{2^N-1}\\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basis States\n",
    "\n",
    "Similarly to single-qubit systems, multi-qubit systems have their own sets of basis states. \n",
    "The computational basis for an $N$-qubit system is a set of $2^N$ vectors, in each of which with one element equals $1$, and the other elements equal $0$. \n",
    "\n",
    "For example, this is the **computational basis** for a two-qubit system:\n",
    "\n",
    "$$\\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix}\\text{, }\n",
    "\\begin{bmatrix} 0 \\\\ 1 \\\\ 0 \\\\ 0 \\end{bmatrix}\\text{, }\n",
    "\\begin{bmatrix} 0 \\\\ 0 \\\\ 1 \\\\ 0 \\end{bmatrix}\\text{, }\n",
    "\\begin{bmatrix} 0 \\\\ 0 \\\\ 0 \\\\ 1 \\end{bmatrix}$$\n",
    "\n",
    "It is easy to see that these vectors form an orthonormal basis. Note that each of these basis states can be represented as a tensor product of some combination of single-qubit basis states:\n",
    "\n",
    "<table>\n",
    "    <col width=200>\n",
    "    <col width=200>\n",
    "    <col width=200>\n",
    "    <col width=200>\n",
    "    <tr>\n",
    "        <td style=\"text-align:center; background-color:white\">$\\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix} =\n",
    "\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}$</td>\n",
    "        <td style=\"text-align:center; background-color:white\">$\\begin{bmatrix} 0 \\\\ 1 \\\\ 0 \\\\ 0 \\end{bmatrix} =\n",
    "\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}$</td>\n",
    "        <td style=\"text-align:center; background-color:white\">$\\begin{bmatrix} 0 \\\\ 0 \\\\ 1 \\\\ 0 \\end{bmatrix} =\n",
    "\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}$</td>\n",
    "        <td style=\"text-align:center; background-color:white\">$\\begin{bmatrix} 0 \\\\ 0 \\\\ 0 \\\\ 1 \\end{bmatrix} =\n",
    "\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} \\otimes \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}$</td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "Any two-qubit system can be expressed as some linear combination of those tensor products of single-qubit basis states.\n",
    "\n",
    "Similar logic applies to systems of more than two qubits. In general case,\n",
    "\n",
    "$$\\begin{bmatrix} x_0 \\\\ x_1 \\\\ \\vdots \\\\ x_{2^N-1} \\end{bmatrix} = \n",
    "x_0 \\begin{bmatrix} 1 \\\\ 0 \\\\ \\vdots \\\\ 0 \\end{bmatrix} + \n",
    "x_1 \\begin{bmatrix} 0 \\\\ 1 \\\\ \\vdots \\\\ 0 \\end{bmatrix} + \\dotsb +\n",
    "x_{2^N-1} \\begin{bmatrix} 0 \\\\ 0 \\\\ \\vdots \\\\ 1 \\end{bmatrix}$$\n",
    "\n",
    "The coefficients of the basis vectors define how \"close\" is the system state to the corresponding basis vector.\n",
    "\n",
    "> Just like with single-qubit systems, there exist other orthonormal bases states for multi-qubit systems. An example for a two-qubit system is the **Bell basis**:\n",
    ">\n",
    "> $$\\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 1 \\end{bmatrix}\\text{, }\n",
    "\\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ -1 \\end{bmatrix}\\text{, }\n",
    "\\frac{1}{\\sqrt{2}}\\begin{bmatrix} 0 \\\\ 1 \\\\ 1 \\\\ 0 \\end{bmatrix}\\text{, }\n",
    "\\frac{1}{\\sqrt{2}}\\begin{bmatrix} 0 \\\\ 1 \\\\ -1 \\\\ 0 \\end{bmatrix}$$\n",
    ">\n",
    "> You can check that these vectors are normalized, and orthogonal to each other, and that any two-qubit state can be expressed as a linear combination of these vectors.  The vectors of Bell basis, however, can not be represented as tensor products of single-qubit basis states."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Separable states\n",
    "\n",
    "Sometimes the state of a multi-qubit system can be separated into the states of individual qubits or smaller subsystems. \n",
    "To do this, you would express the vector state of the system as a [tensor product](../LinearAlgebra/LinearAlgebra.ipynb#Tensor-Product) of the vectors representing each individual qubit/subsystem. \n",
    "Here is an example for two qubits:\n",
    "\n",
    "$$\\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\ 0 \\\\ \\frac{1}{\\sqrt{2}} \\\\ 0 \\end{bmatrix} =\n",
    "\\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\ \\frac{1}{\\sqrt{2}} \\end{bmatrix} \\otimes\n",
    "\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}$$\n",
    "\n",
    "The states that allow such representation are known as **separable states**. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:blue\">Exercise 1</span>: Show that the state is separable\n",
    "\n",
    "$$\\frac{1}{2} \\begin{bmatrix} 1 \\\\ i \\\\ -i \\\\ 1 \\end{bmatrix} =\n",
    "\\begin{bmatrix} ? \\\\ ? \\end{bmatrix} \\otimes \\begin{bmatrix} ? \\\\ ? \\end{bmatrix}$$\n",
    "\n",
    "*Can't come up with a solution? See the explained solution in the [Multi-Qubit Systems Workbook](./Workbook_MultiQubitSystems.ipynb#Exercise-1:-Show-that-the-state-is-separable).*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Note that finding such representation is not always possible, as you will see in the next exercise.\n",
    "\n",
    "### <span style=\"color:blue\">Exercise 2</span>: Is this state separable?\n",
    "\n",
    "$$\\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 1 \\end{bmatrix}$$\n",
    "\n",
    "*Can't come up with a solution? See the explained solution in the [Multi-Qubit Systems Workbook](./Workbook_MultiQubitSystems.ipynb#Exercise-2:-Is-this-state-separable?).*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Entanglement\n",
    "\n",
    "As we've just seen, some quantum states are impossible to factor into individual qubit states or even into states of larger subsystems. The states of these qubits are inseparable from one another and must always be considered as part of a larger system - they are **entangled**.\n",
    "\n",
    "> For example, every state in the Bell basis we saw earlier is an entangled state.\n",
    "\n",
    "Entanglement is a huge part of what makes quantum computing so powerful. \n",
    "It allows us to link the qubits so that they stop behaving like individuals and start behaving like a large, more complex system.\n",
    "In entangled systems, measuring one of the qubits modifies the state of the other qubits, and tells us something about their state. \n",
    "In the example above, when one of the qubits is measured, we know that the second qubit will end up in the same state. \n",
    "This property is used extensively in many quantum algorithms."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dirac Notation\n",
    "\n",
    "Just like with single qubits, [Dirac notation](../Qubit/Qubit.ipynb#Dirac-Notation) provides a useful shorthand for writing down states of multi-qubit systems.\n",
    "\n",
    "As we've seen earlier, multi-qubit systems have their own canonical bases, and the basis states can be represented as tensor products of single-qubit basis states. Any multi-qubit system can be represented as a linear combination of these basis states:\n",
    "\n",
    "$$\\begin{bmatrix} x_0 \\\\ x_1 \\\\ x_2 \\\\ x_3 \\end{bmatrix} =\n",
    "x_0\\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix} +\n",
    "x_1\\begin{bmatrix} 0 \\\\ 1 \\\\ 0 \\\\ 0 \\end{bmatrix} +\n",
    "x_2\\begin{bmatrix} 0 \\\\ 0 \\\\ 1 \\\\ 0 \\end{bmatrix} +\n",
    "x_3\\begin{bmatrix} 0 \\\\ 0 \\\\ 0 \\\\ 1 \\end{bmatrix} =\n",
    "x_0|0\\rangle \\otimes |0\\rangle +\n",
    "x_1|0\\rangle \\otimes |1\\rangle +\n",
    "x_2|1\\rangle \\otimes |0\\rangle +\n",
    "x_3|1\\rangle \\otimes |1\\rangle$$\n",
    "\n",
    "To simplify this, tensor products of basis states have their own notation:\n",
    "\n",
    "$$|0\\rangle \\otimes |0\\rangle = |00\\rangle \\\\\n",
    "|0\\rangle \\otimes |1\\rangle = |01\\rangle \\\\\n",
    "|1\\rangle \\otimes |0\\rangle = |10\\rangle \\\\\n",
    "|1\\rangle \\otimes |1\\rangle = |11\\rangle$$\n",
    "\n",
    "$$|0\\rangle \\otimes |0\\rangle \\otimes |0\\rangle = |000\\rangle$$\n",
    "\n",
    "And so on.\n",
    "\n",
    "Or, more generally:\n",
    "\n",
    "$$|i_0\\rangle \\otimes |i_1\\rangle \\otimes \\dotsb \\otimes |i_n\\rangle = |i_0i_1...i_n\\rangle$$\n",
    "\n",
    "Using this notation simplifies our example:\n",
    "\n",
    "$$\\begin{bmatrix} x_0 \\\\ x_1 \\\\ x_2 \\\\ x_3 \\end{bmatrix} =\n",
    "x_0|00\\rangle + x_1|01\\rangle + x_2|10\\rangle + x_3|11\\rangle$$\n",
    "\n",
    "Just like with single qubits, we can put arbitrary symbols within the kets the same way variables are used in algebra. \n",
    "Whether a ket represents a single qubit or an entire system depends on the context. \n",
    "Some ket symbols have a commonly accepted usage, such as the symbols for the Bell basis:\n",
    "\n",
    "<table>\n",
    "    <col width=300>\n",
    "    <col width=300>\n",
    "    <tr>\n",
    "        <td style=\"text-align:center; background-color:white\">$|\\Phi^+\\rangle = \\frac{1}{\\sqrt{2}}\\big(|00\\rangle + |11\\rangle\\big) \\\\ |\\Phi^-\\rangle = \\frac{1}{\\sqrt{2}}\\big(|00\\rangle - |11\\rangle\\big)$</td>\n",
    "        <td style=\"text-align:center; background-color:white\">$|\\Psi^+\\rangle = \\frac{1}{\\sqrt{2}}\\big(|01\\rangle + |10\\rangle\\big) \\\\ |\\Psi^-\\rangle = \\frac{1}{\\sqrt{2}}\\big(|01\\rangle - |10\\rangle\\big)$</td>\n",
    "    </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">## Endianness\n",
    ">\n",
    "> In classical computing, endianness refers to the order of bits (or bytes) when representing numbers in binary. You're probably familiar with the typical way of writing numbers in binary: $0 = 0_2$, $1 = 1_2$, $2 = 10_2$, $3 = 11_2$, $4 = 100_2$, $5 = 101_2$, $6 = 110_2$, etc. This is known as **big-endian format**. In big-endian format, the *most significant* bits come first. For example: $110_2 = 1 \\cdot 4 + 1 \\cdot 2 + 0 \\cdot 1 = 4 + 2 = 6$.\n",
    ">\n",
    "> There is an alternate way of writing binary numbers - **little-endian format**. In little-endian format, the *least significant* bits come first. For example, $2$ would be written as $01$, $4$ as $001$, and $6$ as $011$. To put it another way, in little endian format, the number is written backwards compared to the big-endian format.\n",
    ">\n",
    "> In Dirac notation for multi-qubit systems, it's common to see integer numbers within the kets instead of bit sequences. What those numbers mean depends on the context - whether the notation used is big-endian or little-endian.\n",
    ">\n",
    "> Examples with a 3 qubit system:\n",
    ">\n",
    "> <table>\n",
    ">    <tr>\n",
    ">        <th style=\"text-align:center; border:1px solid\">Integer Ket</th>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|0\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|1\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|2\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|3\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|4\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|5\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|6\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|7\\rangle$</td>\n",
    ">    </tr>\n",
    ">    <tr>\n",
    ">        <th style=\"text-align:center; border:1px solid\">Big-endian</th>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|000\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|001\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|010\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|011\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|100\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|101\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|110\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|111\\rangle$</td>\n",
    ">    </tr>\n",
    ">    <tr>\n",
    ">        <th style=\"text-align:center; border:1px solid\">Little-endian</th>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|000\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|100\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|010\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|110\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|001\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|101\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|011\\rangle$</td>\n",
    ">        <td style=\"text-align:center; border:1px solid\">$|111\\rangle$</td>\n",
    ">    </tr>\n",
    "></table>\n",
    ">\n",
    "> Multi-qubit quantum systems that store superpositions of numbers are often referred to as **quantum registers**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:blue\">Demo: Multi-qubit systems</span>\n",
    "\n",
    "This demo shows you how to allocate multiple qubits in Q# and examine their joint state. It uses single-qubit gates for manipulating the individual qubit states - if you need a refresher on them, please see the [corresponding tutorial](../SingleQubitGates/SingleQubitGates.ipynb).\n",
    "\n",
    "These demos use the function `DumpMachine` to print the state of the quantum simulator. \n",
    "If you aren't familiar with the output of this function for single qubits, you should revisit the tutorial on [the concept of a qubit](../Qubit/Qubit.ipynb#Demo:-Examining-Qubit-States-in-Q#). \n",
    "When printing the state of multi-qubit systems, this function outputs the same information for each multi-qubit basis state.\n",
    "[This tutorial](../VisualizationTools/VisualizationTools.ipynb#Demo:-DumpMachine-for-multi-qubit-systems) explains how `DumpMachine` works for multiple qubits in more detail. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Run this cell using Ctrl+Enter (⌘+Enter on Mac)\n",
    "// Then run the next cell to see the output\n",
    "\n",
    "open Microsoft.Quantum.Diagnostics;\n",
    "\n",
    "operation MultiQubitSystemsDemo () : Unit {\n",
    "    // This allocates an array of 2 qubits, each of them in state |0⟩.\n",
    "    // The overall state of the system is |00⟩\n",
    "    use qs = Qubit[2];\n",
    "    // X gate changes the first qubit into state |1⟩\n",
    "    // The entire system is now in state |10⟩\n",
    "    X(qs[0]);\n",
    "\n",
    "    Message(\"System in state |10⟩:\");\n",
    "    DumpMachine();\n",
    "\n",
    "    // This changes the second qubit into state |+⟩ = (1/sqrt(2))(|0⟩ + |1⟩).\n",
    "    // The entire system is now in state (1/sqrt(2))(|10⟩ + |11⟩)\n",
    "    H(qs[1]);\n",
    "\n",
    "    Message(\"System in state (1/sqrt(2))(|10⟩ + |11⟩):\");\n",
    "    DumpMachine();\n",
    "\n",
    "    // This changes the first qubit into state |-⟩ = (1/sqrt(2))(|0⟩ - |1⟩)\n",
    "    // The entire system is now in state 0.5(|00⟩ + |01⟩ - |10⟩ - |11⟩)\n",
    "    H(qs[0]);\n",
    "\n",
    "    Message(\"System in state 0.5(|00⟩ + |01⟩ - |10⟩ - |11⟩):\");\n",
    "    DumpMachine();\n",
    "\n",
    "    // You can use DumpRegister to examine the state of specific qubits rather than the entire simulator.\n",
    "    // This prints the state of the first qubit\n",
    "    Message(\"First qubit (in state |-⟩ = (1/sqrt(2))(|0⟩ - |1⟩):\");\n",
    "    DumpRegister((), [qs[0]]);\n",
    "\n",
    "    // The next lines entangle the qubits.\n",
    "    // Don't worry about what exactly they do for now\n",
    "    H(qs[1]);\n",
    "    CNOT(qs[0], qs[1]);\n",
    "\n",
    "    Message(\"Entangled state 0.5(|00⟩ - |11⟩):\");\n",
    "    DumpMachine();\n",
    "\n",
    "    // Since the states of entangled qubits are inseparable,\n",
    "    // it makes no sense to examine only one of them\n",
    "    Message(\"Let's try to examine one of two entangled qubits on its own...\");\n",
    "    DumpRegister((), [qs[0]]);\n",
    "\n",
    "    // This returns the system into state |00⟩\n",
    "    ResetAll(qs);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%simulate MultiQubitSystemsDemo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> You might have noticed that we've been \"resetting\" the qubits at the end of our demos, i.e., returning them to $|0\\rangle$ state. Q# requires you to return your qubits into the $|0\\rangle$ state before releasing them at the end of the `using` block. \n",
    "> The reason for this is entanglement. \n",
    ">\n",
    "> Consider running a program on a quantum computer: the number of qubits is very limited, and you want to reuse the released qubits in other parts of the program. \n",
    "If they are not in zero state by that time, they can potentially be still entangled with the qubits which are not yet released, thus operations you perform on them can affect the state of other parts of the program, causing erroneous and hard to debug behavior.\n",
    ">\n",
    "> Resetting the qubits to zero state automatically when they go outside the scope of their using block is dangerous as well: if they were entangled with others, measuring them to reset them can affect the state of the unreleased qubits, and thus change the results of the program - without the developer noticing this.\n",
    ">\n",
    "> The requirement that the qubits should be in zero state before they can be released aims to remind the developer to double-check that all necessary information has been properly extracted from the qubits, and that they are not entangled with unreleased qubits any more.\n",
    ">\n",
    "> (An alternative way to break entanglement is to measure qubits; in this case Q# allows to release them regardless of the measurement result. You can learn more about measurements in [this tutorial](../SingleQubitSystemMeasurements/SingleQubitSystemMeasurements.ipynb).)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following exercises you will learn to prepare separable quantum states by manipulating individual qubits. \n",
    "You will only need [single-qubit gates](../SingleQubitGates/SingleQubitGates.ipynb) for that.\n",
    "\n",
    "> In each exercise, you'll be given an array of qubits to manipulate; you can access $i$-th element of the array `qs` as `qs[i]`. \n",
    "Array elements are indexed starting with 0, the first array element corresponds to the leftmost qubit in Dirac notation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:blue\">Exercise 3</span>: Prepare a basis state\n",
    "\n",
    "**Input:** A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix}$.\n",
    "\n",
    "**Goal:** Transform the system into the basis state $|11\\rangle = \\begin{bmatrix} 0 \\\\ 0 \\\\ 0 \\\\ 1 \\end{bmatrix}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T1_PrepareState1\n",
    "\n",
    "operation PrepareState1 (qs : Qubit[]) : Unit is Adj+Ctl {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Can't come up with a solution? See the explained solution in the [Multi-Qubit Systems Workbook](./Workbook_MultiQubitSystems.ipynb#Exercise-3:-Prepare-a-basis-state).*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:blue\">Exercise 4</span>: Prepare a superposition of two basis states\n",
    "\n",
    "**Input:** A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix}$.\n",
    "\n",
    "**Goal:** Transform the system into the state $\\frac{1}{\\sqrt2}\\big(|00\\rangle - |01\\rangle\\big) = \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ -1 \\\\ 0 \\\\ 0 \\end{bmatrix}$.\n",
    "\n",
    "<details>\n",
    "    <summary><b>Need a hint? Click here</b></summary>\n",
    "    Represent the target state as a tensor product $|0\\rangle \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big) = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ -1 \\end{bmatrix}$.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T2_PrepareState2\n",
    "\n",
    "operation PrepareState2 (qs : Qubit[]) : Unit is Adj+Ctl {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Can't come up with a solution? See the explained solution in the [Multi-Qubit Systems Workbook](./Workbook_MultiQubitSystems.ipynb#Exercise-4:-Prepare-a-superposition-of-two-basis-states).*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:blue\">Exercise 5</span>: Prepare a superposition with real amplitudes\n",
    "\n",
    "**Input:** A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix}$.\n",
    "\n",
    "**Goal:** Transform the system into the state $\\frac{1}{2}\\big(|00\\rangle - |01\\rangle + |10\\rangle - |11\\rangle\\big) = \\frac{1}{2}\\begin{bmatrix} 1 \\\\ -1 \\\\ 1 \\\\ -1 \\end{bmatrix}$.\n",
    "\n",
    "<details>\n",
    "    <summary><b>Need a hint? Click here</b></summary>\n",
    "    Represent the target state as a tensor product $\\frac{1}{\\sqrt2}\\big(|0\\rangle + |1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle - |1\\rangle\\big) = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ -1 \\end{bmatrix}$.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T3_PrepareState3\n",
    "\n",
    "operation PrepareState3 (qs : Qubit[]) : Unit is Adj+Ctl {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Can't come up with a solution? See the explained solution in the [Multi-Qubit Systems Workbook](./Workbook_MultiQubitSystems.ipynb#Exercise-5:-Prepare-a-superposition-with-real-amplitudes).*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:blue\">Exercise 6</span>: Prepare a superposition with complex amplitudes\n",
    "\n",
    "**Input:** A two-qubit system in the basis state $|00\\rangle = \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix}$.\n",
    "\n",
    "**Goal:** Transform the system into the state $\\frac{1}{2}\\big(|00\\rangle + e^{i\\pi/4}|01\\rangle + e^{i\\pi/2}|10\\rangle + e^{3i\\pi/4}|11\\rangle\\big) = \\frac{1}{2}\\begin{bmatrix} 1 \\\\ e^{i\\pi/4} \\\\ e^{i\\pi/2} \\\\ e^{3i\\pi/4} \\end{bmatrix}$.\n",
    "\n",
    "<details>\n",
    "    <summary><b>Need a hint? Click here</b></summary>\n",
    "    Represent the target state as a tensor product $\\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/2}|1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/4}|1\\rangle\\big) = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ e^{i\\pi/2} \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ e^{i\\pi/4} \\end{bmatrix}$.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%kata T4_PrepareState4\n",
    "\n",
    "operation PrepareState4 (qs : Qubit[]) : Unit is Adj+Ctl {\n",
    "    // ...\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Can't come up with a solution? See the explained solution in the [Multi-Qubit Systems Workbook](./Workbook_MultiQubitSystems.ipynb#Exercise-6:-Prepare-a-superposition-with-complex-amplitudes).*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "As you've seen in the exercises, you can prepare separable multi-qubit states using only single-qubit gates. \n",
    "However, to prepare and manipulate entangled states you'll need more powerful tools. \n",
    "In the [next tutorial](../MultiQubitGates/MultiQubitGates.ipynb) you will learn about multi-qubit gates which give you access to all states of multi-qubit systems."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Q#",
   "language": "qsharp",
   "name": "iqsharp"
  },
  "language_info": {
   "file_extension": ".qs",
   "mimetype": "text/x-qsharp",
   "name": "qsharp",
   "version": "0.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}