Xanadu Quantum Codebook/Shor/Quantum_Codebook_S3.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LM72yVrDLX7p"
      },
      "source": [
        "# S.3 Period finding\n",
        "\n",
        "Shor's algorithm is characterized by having a classical part and a quantum part. In particular, the quantum part is in charge of searching efficiently for nontrivial square roots using an algorithm called period finding. "
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Author: [Monit Sharma](https://github.com/MonitSharma)\n",
        "LinkedIn: [Monit Sharma](https://www.linkedin.com/in/monitsharma/)\n",
        "Twitter: [@MonitSharma1729](https://twitter.com/MonitSharma1729)\n",
        "Medium : [MonitSharma](https://medium.com/@_monitsharma)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bOdN1JhbLZ3p"
      },
      "source": [
        "![](https://codebook.xanadu.ai/pics/PF_circuit.jpg)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z_Hv14joLfGQ"
      },
      "source": [
        "### Codercise S.3.1. \n",
        "Implement the above circuit for\n",
        ". We will make use of PennyLane's get_unitary_matrix function which, given a quantum function, returns the associated matrix. Finally, we will use the get_phase function to translate the output to a decimal value."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Prqxc5_pJrG0"
      },
      "outputs": [],
      "source": [
        "def U():\n",
        "    qml.SWAP(wires=[2,3])\n",
        "    qml.SWAP(wires=[1,2])\n",
        "    qml.SWAP(wires=[0,1])\n",
        "    for i in range(4):\n",
        "        qml.PauliX(wires=i)\n",
        "\n",
        "matrix = get_unitary_matrix(U, wire_order=range(4))()\n",
        "\n",
        "n_target_wires = 4\n",
        "target_wires = range(n_target_wires)\n",
        "n_estimation_wires = 3\n",
        "estimation_wires = range(4, 4 + n_estimation_wires)\n",
        "\n",
        "\n",
        "dev = qml.device(\"default.qubit\", shots=1, wires=n_target_wires+n_estimation_wires)\n",
        "\n",
        "@qml.qnode(dev)\n",
        "def circuit(matrix):\n",
        "    \"\"\"Return a sample after taking a shot at the estimation wires.\n",
        "    \n",
        "    Args:\n",
        "        matrix (array[complex]): matrix representation of U.\n",
        "\n",
        "    Returns:\n",
        "        array[float]: a sample after taking a shot at the estimation wires.\n",
        "    \"\"\"\n",
        "    \n",
        "    ##################\n",
        "    # YOUR CODE HERE #\n",
        "    ##################\n",
        "    \n",
        "    # CREATE THE INITIAL STATE |0001> ON TARGET WIRES\n",
        "    qml.PauliX(wires=3)\n",
        "    # USE THE SUBROUTINE QUANTUM PHASE ESTIMATION\n",
        "    qml.QuantumPhaseEstimation(matrix,[0,1,2,3],[4,5,6])\n",
        "    \n",
        "    return qml.sample(wires=estimation_wires)\n",
        "\n",
        "def get_phase(matrix):\n",
        "    binary = \"\".join([str(b) for b in circuit(matrix)])\n",
        "    return int(binary, 2) / 2 ** n_estimation_wires\n",
        "\n",
        "for i in range(5):\n",
        "    print(circuit(matrix))\n",
        "    print(f\"shot {i+1}, phase:\",get_phase(matrix))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ahDhIStWLjDZ"
      },
      "source": [
        "### Codercise S.3.2. \n",
        "Assuming that we have the get_phase function, obtain the value of the period with the procedure explained above. Help yourself to the function Fraction (it is already imported for you)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "61Q7mBc3Lk1Z"
      },
      "outputs": [],
      "source": [
        "def U():\n",
        "    qml.SWAP(wires=[2,3])\n",
        "    qml.SWAP(wires=[1,2])\n",
        "    qml.SWAP(wires=[0,1])\n",
        "    for i in range(4):\n",
        "        qml.PauliX(wires=i)\n",
        "\n",
        "matrix = get_unitary_matrix(U, wire_order=range(4))()\n",
        "\n",
        "target_wires = range(4)\n",
        "n_estimation_wires = 3\n",
        "estimation_wires = range(4, 4 + n_estimation_wires)\n",
        "\n",
        "def get_period(matrix):\n",
        "    \"\"\"Return the period of the state using the already-defined \n",
        "    get_phase function.\n",
        "    \n",
        "    Args:\n",
        "        matrix (array[complex]): matrix associated with the operator U\n",
        "        \n",
        "    Returns:\n",
        "        int: Obtained period of the state.\n",
        "    \"\"\"\n",
        "    \n",
        "    shots = 10\n",
        "    \n",
        "    ##################\n",
        "    # YOUR CODE HERE #\n",
        "    ##################\n",
        "    arr = []\n",
        "    for _ in range(shots):\n",
        "        x = get_phase(matrix)\n",
        "        f = Fraction(x).limit_denominator(2**3)\n",
        "        \n",
        "        if x==0:\n",
        "            continue\n",
        "        else:\n",
        "            arr.append(f.denominator)\n",
        "    lcm =1\n",
        "    for _ in arr:\n",
        "        lcm = lcm*_//np.gcd(lcm,_)\n",
        "    return lcm\n",
        "    \n",
        "\n",
        "    \n",
        "\n",
        "print(get_period(matrix))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3xMYQxHcLnLQ"
      },
      "source": [
        "### Codercise S.3.3. \n",
        "Create a circuit in which the operator is executed four times on the state\n",
        "to check that the results obtained in the previous exercise are consistent."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vRtqmyw3Loa5"
      },
      "outputs": [],
      "source": [
        "def U():\n",
        "    qml.SWAP(wires=[2,3])\n",
        "    qml.SWAP(wires=[1,2])\n",
        "    qml.SWAP(wires=[0,1])\n",
        "    for i in range(4):\n",
        "        qml.PauliX(wires=i)\n",
        "\n",
        "dev = qml.device(\"default.qubit\", wires=4)\n",
        "\n",
        "@qml.qnode(dev)\n",
        "def circuit():\n",
        "    \"\"\"Apply U four times to |0001> to verify this is the period.\n",
        "    \n",
        "    Returns:\n",
        "        array[float]: probabilities of each basis state. \n",
        "    \"\"\"\n",
        "    \n",
        "    ##################\n",
        "    # YOUR CODE HERE #\n",
        "    ##################\n",
        "    qml.PauliX(wires=3)\n",
        "    U()\n",
        "    U()\n",
        "    U()\n",
        "    U()\n",
        "    \n",
        "    \n",
        "    return qml.probs(wires=range(4))\n",
        "\n",
        "\n",
        "print(circuit())\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}