Coding_Challenges/qml_100_GeneratingFourierState_template/qml_100_GeneratingFourierState.ipynb

{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "name": "qml_100_GeneratingFourierState.ipynb",
   "private_outputs": true,
   "provenance": [],
   "authorship_tag": "ABX9TyPtJr7lQ/KNXkNarv/JR2eJ",
   "include_colab_link": true
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "view-in-github",
    "colab_type": "text"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/JavierPerez21/QHack2022/blob/master/Coding_Challenges/qml_100_GeneratingFourierState_template/qml_100_GeneratingFourierState.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-FcMgnBE1Jz7"
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "!pip install pennylane"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "from pennylane import numpy as np\n",
    "import pennylane as qml"
   ],
   "metadata": {
    "id": "kjX5L9t-8BhY"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "In quantum computing we usually work in the $\\sigma^z$ basis. To go to the fourier basis we need to apply [Quantum Fourier Transforms](https://qiskit.org/textbook/ch-algorithms/quantum-fourier-transform.html). \n",
    "\n",
    "The goal of this challenge is to crete the QFT operation from scratch training a [VQE](https://pennylane.ai/qml/demos/tutorial_vqe.html) by completing the function below."
   ],
   "metadata": {
    "id": "2Na_aR5R1j7i"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def generating_fourier_state(n_qubits, m):\n",
    "    \"\"\"Function which, given the number of qubits and an integer m, returns the circuit and the angles that generate the state\n",
    "    QFT|m> following the above template.\n",
    "\n",
    "    Args:\n",
    "        - n_qubits (int): number of qubits in the circuit.\n",
    "        - m (int): basis state that we generate. For example, for 'm = 3' and 'n_qubits = 4'\n",
    "        we would generate the state QFT|0011> (3 in binary is 11).\n",
    "\n",
    "    Returns:\n",
    "       - (qml.QNode): circuit used to generate the state.\n",
    "       - (list[float]): angles that generate the state QFT|m>.\n",
    "    \"\"\"\n",
    "\n",
    "    dev = qml.device(\"default.qubit\", wires=n_qubits)\n",
    "\n",
    "    @qml.qnode(dev)\n",
    "    def circuit(angles):\n",
    "        \"\"\"This is the quantum circuit that we will use.\"\"\"\n",
    "\n",
    "        # QHACK #\n",
    "\n",
    "        # Add the template of the statement with the angles passed as an argument.\n",
    "        for i in range(n_qubits):\n",
    "          qml.Hadamard(wires = i)\n",
    "          qml.RZ(angles[i], wires = i)\n",
    "\n",
    "        # QHACK #\n",
    "\n",
    "        # We apply QFT^-1 to return to the computational basis.\n",
    "        # This will help us to see how well we have done.\n",
    "        qml.adjoint(qml.QFT)(wires=range(n_qubits))\n",
    "\n",
    "        # We return the probabilities of seeing each basis state.\n",
    "        return qml.probs(wires=range(n_qubits))\n",
    "\n",
    "    def error(angles):\n",
    "        \"\"\"This function will determine, given a set of angles, how well it approximates\n",
    "        the desired state. Here it will be necessary to call the circuit to work with these results.\n",
    "        \"\"\"\n",
    "\n",
    "        probs = circuit(angles)\n",
    "        # QHACK #\n",
    "\n",
    "        # The return error should be smaller when the state m is more likely to be obtained.\n",
    "        return np.sum(probs**2) + 1 - 2*probs[m]\n",
    "\n",
    "        # QHACK #\n",
    "\n",
    "    # This subroutine will find the angles that minimize the error function.\n",
    "    # Do not modify anything from here.\n",
    "\n",
    "    opt = qml.AdamOptimizer(stepsize=0.8)\n",
    "    epochs = 1000\n",
    "\n",
    "    angles = np.zeros(n_qubits, requires_grad=True)\n",
    "\n",
    "    for epoch in range(epochs):\n",
    "        angles = opt.step(error, angles)\n",
    "        angles = np.clip(opt.step(error, angles), -2 * np.pi, 2 * np.pi)\n",
    "        print(f\"Epoch {epoch}: error: {error(angles)} angles: {angles}\")\n",
    "\n",
    "    return circuit, angles"
   ],
   "metadata": {
    "id": "a4kQkmjb7D6w"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "Testing with 1.in"
   ],
   "metadata": {
    "id": "BfxHq94x70he"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "inputs = [2, 3]\n",
    "n_qubits = int(inputs[0])\n",
    "m = int(inputs[1])\n",
    "\n",
    "output = generating_fourier_state(n_qubits, m)\n",
    "output[0](output[1])\n",
    "dev = qml.device(\"default.qubit\", wires=n_qubits)\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def check_with_arbitrary_state():\n",
    "    for i in range(n_qubits):\n",
    "        qml.RY(i, wires=i)\n",
    "    for op in output[0].qtape.operations:\n",
    "        qml.apply(op)\n",
    "    return qml.state()\n",
    "\n",
    "print(\",\".join([f\"{p.real.round(5)},{p.imag.round(5)}\" for p in check_with_arbitrary_state()]))"
   ],
   "metadata": {
    "id": "kCKva4ur733V"
   },
   "execution_count": null,
   "outputs": []
  }
 ]
}