ipynb/0.4-Product_Management.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e4532ddd",
   "metadata": {},
   "source": [
    "##### Tutorial Challenges\n",
    "\n",
    "# 4. Product Management (0 points)\n",
    "\n",
    "Welcome to the QHack 2023 daily challenges! Every day for the next four days, you will receive two new challenges to complete. These challenges are worth no points — they are specifically designed to get your brain active and into the right mindset for the competition. You will also learn about various aspects of PennyLane that are essential to quantum computing, quantum machine learning, and quantum chemistry. Have fun!\n",
    "\n",
    "## Tutorial \\#4 — Product states\n",
    "\n",
    "Entanglement is a quantum phenomenon that leads to unique statistical properties. We can harness it to do seemingly far-fetched tasks like quantum teleportation!\n",
    "\n",
    "Given a multi-qubit *pure* state (i.e., does not need to be described by a density operator), the presence of entanglement boils down to whether or not the state is a *product* state. Given a two-qubit state where the qubits are labelled by $A$ and $B$, a general pure quantum state can be written as\n",
    "\n",
    "$$|\\psi\\rangle_{AB} = \\sum_{i,j} c_{ij} |i\\rangle_A \\otimes |j\\rangle_B$$\n",
    "\n",
    "$|\\psi\\rangle_{AB}$ is said to be a product state for subsystems $A$ and $B$ if it can be written as a tensor product\n",
    "\n",
    "$$|\\psi\\rangle_{AB} = |\\psi\\rangle_A \\otimes |\\psi\\rangle_B$$\n",
    "\n",
    "For example, the well-known Bell states cannot be written as product states between the two qubits.\n",
    "\n",
    "Your job is to create a function that can tell whether or not a pure state can be written as a product state between a subsystem and its complement (e.g., if $A$ is the subsystem, then $B = \\bar{A}$, meaning that system $B$ is the set of qubits that are not in $A$).\n",
    "\n",
    "## Challenge code\n",
    "\n",
    "In the code below, you are given a function called `is_product`. This function will output `\"yes\"` or `\"no\"` correspondingly. **You must complete this function.**\n",
    "\n",
    "Here are some helpful resources:\n",
    "\n",
    "- [Separable quantum states](https://en.wikipedia.org/wiki/Separable_state)\n",
    "- [`qml.density_matrix`](https://docs.pennylane.ai/en/stable/code/api/pennylane.density_matrix.html)\n",
    "\n",
    "### Input\n",
    "\n",
    "As input to this problem, you are given:\n",
    "\n",
    "- `state` (`list(float)`): this defines $|\\psi\\rangle_{AB}$ (pure quantum state in question).\n",
    "- `subsystem` (`list(int)`): the subsystem that defines the subsystem of qubits $A$ and $B = \\bar{A}$. I.e., the two groups of qubits that you will determine if a state can be written as a product state.\n",
    "- `wires` (`list(int)`): the wire labels associated to the qubit state of interest.\n",
    "\n",
    "### Output\n",
    "\n",
    "This code must output `\"yes\"` or `\"no\"` if the state $|\\psi\\rangle_{AB}$ is a product state (with respect to $A$ and $B$).\n",
    "\n",
    "If your solution matches the correct one, the output will be `\"Correct!\"` Otherwise, you will receive a `\"Wrong answer\"` prompt.\n",
    "\n",
    "Good luck!\n",
    "\n",
    "### Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ca44a484",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pennylane as qml\n",
    "import pennylane.numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "445d4cb0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'no'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_product(state, subsystem, wires):\n",
    "    \"\"\"Determines if a pure quantum state can be written as a product state between \n",
    "    a subsystem of wires and their compliment.\n",
    "\n",
    "    Args:\n",
    "        state (numpy.array): The quantum state of interest.\n",
    "        subsystem (list(int)): The subsystem used to determine if the state is a product state.\n",
    "        wires (list(int)): The wire/qubit labels for the state. Use these for creating a QNode if you wish!\n",
    "\n",
    "    Returns:\n",
    "        (str): \"yes\" if the state is a product state or \"no\" if it isn't.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Put your solution here #\n",
    "    \n",
    "    # partial trace subsystem\n",
    "    @qml.qnode(qml.device(\"default.mixed\", wires=wires))\n",
    "    def circuit():\n",
    "        qml.QubitStateVector(state, wires=wires)\n",
    "        return qml.density_matrix(wires=subsystem)\n",
    "    \n",
    "    # check if subsystem is still pure (i.e. separable)\n",
    "    rho = circuit()\n",
    "    purity = np.trace(np.matmul(rho, rho))\n",
    "    \n",
    "    return \"yes\" if purity == 1 else \"no\"\n",
    "\n",
    "is_product([0.707107, 0, 0, 0.707107], [0], [0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f6e313db",
   "metadata": {},
   "outputs": [],
   "source": [
    "# These functions are responsible for testing the solution.\n",
    "def run(test_case_input: str) -> str:\n",
    "    ins = json.loads(test_case_input)\n",
    "    state, subsystem, wires = ins\n",
    "    state = np.array(state)\n",
    "    output = is_product(state, subsystem, wires)\n",
    "    return output\n",
    "\n",
    "def check(solution_output: str, expected_output: str) -> None:\n",
    "    assert solution_output == expected_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f4d07aa6",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cases = [['[[0.707107, 0, 0, 0.707107], [0], [0, 1]]', 'no'], ['[[1, 0, 0, 0], [0], [0, 1]]', 'yes']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8ab93a3c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running test case 0 with input '[[0.707107, 0, 0, 0.707107], [0], [0, 1]]'...\n",
      "Correct!\n",
      "Running test case 1 with input '[[1, 0, 0, 0], [0], [0, 1]]'...\n",
      "Correct!\n"
     ]
    }
   ],
   "source": [
    "for i, (input_, expected_output) in enumerate(test_cases):\n",
    "    print(f\"Running test case {i} with input '{input_}'...\")\n",
    "\n",
    "    try:\n",
    "        output = run(input_)\n",
    "\n",
    "    except Exception as exc:\n",
    "        print(f\"Runtime Error. {exc}\")\n",
    "\n",
    "    else:\n",
    "        if message := check(output, expected_output):\n",
    "            print(f\"Wrong Answer. Have: '{output}'. Want: '{expected_output}'.\")\n",
    "\n",
    "        else:\n",
    "            print(\"Correct!\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pennylane",
   "language": "python",
   "name": "pennylane"
  },
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}