Coding_Challenges/qchem_100_IsParticlePreserving_template/qchem_100_IsParticlePreserving.ipynb

{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "name": "qchem_100_IsParticlePreserving.ipynb",
   "private_outputs": true,
   "provenance": [],
   "authorship_tag": "ABX9TyOGIw4VUiR3LqPGWnnnJylD",
   "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/qchem_100_IsParticlePreserving_template/qchem_100_IsParticlePreserving.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": "5vIe1pBQYy-x"
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "!pip install pennylane"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "import pennylane as qml\n",
    "from pennylane import numpy as np\n",
    "from pennylane import hf"
   ],
   "metadata": {
    "id": "5Kgz0liHZAR6"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "In quantum chemistry, we represent the states of electrons in an atom by labelling the occupation levels. This notation is known as the Jordan-Wigner representation. We write 1 when an energy level is occupied and 0 when it is not. Consider the state $|1001\\rangle$. In it, the first two states correspond to the first energy level and the ast two, to the second energy level.\n",
    "\n",
    "The goal of this challenge is to predict if a unitary operator will be particle preserving, that is, whether its output will have the same number of ones (electrons) as the input, which is essential for quantum chemistry (this is also called preserving the Hamming weight).\n",
    "\n",
    "To do this, we have to complete three functions:\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ],
   "metadata": {
    "id": "lY0QN7Z-ZApE"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def binary_list(m, n):\n",
    "    \"\"\"Converts number m to binary encoded on a list of length n\n",
    "\n",
    "    Args:\n",
    "        - m (int): Number to convert to binary\n",
    "        - n (int): Number of wires in the circuit\n",
    "\n",
    "    Returns:\n",
    "        - (list(int)): Binary stored as a list of length n\n",
    "    \"\"\"\n",
    "\n",
    "    arr = []\n",
    "\n",
    "    # QHACK #\n",
    "\n",
    "    # Create the 0 representation of length n\n",
    "    for i in range(0, n):\n",
    "        arr.append(0)\n",
    "    i = 0\n",
    "\n",
    "    # Set the elements of arr to represent m\n",
    "    while m != 0:\n",
    "        arr[len(arr) - 1 - i] = int(m) % 2\n",
    "        m = int(m / 2)\n",
    "        i += 1\n",
    "    # QHACK #\n",
    "    return arr"
   ],
   "metadata": {
    "id": "E2oDh-QcbM9m"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "def basis_states(n):\n",
    "    \"\"\"Given a number n, returns a list of all binary_list(m,n) for m < 2**n, thus providing all basis states\n",
    "         for a circuit of n wires\n",
    "\n",
    "    Args:\n",
    "        - n(int): integer representing the number of wires in the circuit\n",
    "\n",
    "    Returns:\n",
    "        - (list(list(int))): list of basis states represented as lists of 0s and 1s.\n",
    "    \"\"\"\n",
    "\n",
    "    arr = []\n",
    "\n",
    "    # QHACK #\n",
    "    # Create all possible binary lists from 0 to 2**n\n",
    "    for i in range(0, 2**n):\n",
    "        arr.append(binary_list(i, n))\n",
    "    # QHACK #\n",
    "    return arr"
   ],
   "metadata": {
    "id": "cAvtzapjcQOI"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "def is_particle_preserving(circuit, n):\n",
    "    \"\"\"Given a circuit and its number of wires n, returns 1 if it preserves the number of particles, and 0 if it does not\n",
    "\n",
    "    Args:\n",
    "        - circuit (qml.QNode): A QNode that has a state such as [0,0,1,0] as an input and outputs the final state after performing\n",
    "        quantum operation\n",
    "        - n (int): the number of wires of circuit\n",
    "\n",
    "    Returns:\n",
    "        - (bool): True / False according to whether the input circuit preserves the number of particles or not\n",
    "    \"\"\"\n",
    "    # QHACK #\n",
    "    states = basis_states(n)\n",
    "    for i, state in enumerate(states):\n",
    "        print(i)\n",
    "        initial_particles = sum(state)\n",
    "        print(f\"Initial state: {i}={state} with {initial_particles} particles\")\n",
    "        # Calculate output state\n",
    "        output_state = circuit(state)\n",
    "        # Obtain all possible outputs when sampling\n",
    "        non_zeros = [x for x in np.where(np.real(output_state .numpy())**2 > 0)[0]]\n",
    "        possible_outputs = [binary_list(x, n) for x in non_zeros]\n",
    "        print(\"Possible output states with numbers of particles\", [str(x) + \" w. \" + str(sum(x)) for x in possible_outputs])\n",
    "        # Calculate number of particles of every possible output\n",
    "        for out in possible_outputs:\n",
    "          output_particles = sum(out)\n",
    "          if initial_particles != output_particles:\n",
    "              # Return False whenever the initial_particles are not the same as the output_particles\n",
    "              return False\n",
    "    # Return True in the default case when the circuit is particle preserving\n",
    "    return True\n",
    "    # QHACK #"
   ],
   "metadata": {
    "id": "sLdQz1QYcZIe"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "Testing for 1.in"
   ],
   "metadata": {
    "id": "8iUxt75Wc3Ps"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "inputs = \"4;Hadamard;0;CNOT;0,1;Hadamard;0\".split(\";\")\n",
    "gate_list = []\n",
    "wire_list = []\n",
    "param_list = []\n",
    "i = 1\n",
    "\n",
    "while i < len(inputs):\n",
    "    gate_obj = getattr(qml, str(inputs[i]))\n",
    "    gate_wires = gate_obj.num_wires\n",
    "    input_wires = list(map(int, str(inputs[i + 1]).split(\",\")))\n",
    "    gate_list.append(str(inputs[i]))\n",
    "    wire_list.append(input_wires)\n",
    "    if \"non_parametric_ops\" not in gate_obj.__module__.split(\".\"):\n",
    "        input_params = list(map(float, str(inputs[i + 2]).split(\",\")))\n",
    "        param_list.append(input_params)\n",
    "        i += 1\n",
    "    i += 2\n",
    "\n",
    "wire_list = np.array(wire_list, dtype=object)\n",
    "param_list = np.array(param_list, dtype=object)\n",
    "\n",
    "n = int(inputs[0])\n",
    "dev = qml.device(\"default.qubit\", wires=n)\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def circ(gate_list, wire_list, param_list, state):\n",
    "    qml.BasisState(np.array(state), wires=range(n))\n",
    "    j = 0\n",
    "    for i in range(len(gate_list)):\n",
    "        gate = getattr(qml, str(gate_list[i]))\n",
    "        if \"non_parametric_ops\" not in gate.__module__.split(\".\"):\n",
    "            gate(*param_list[j], wires=[int(w) for w in wire_list[i]])\n",
    "            j += 1\n",
    "        else:\n",
    "            gate(wires=[int(w) for w in wire_list[i]])\n",
    "    return qml.state()\n",
    "\n",
    "def circuit(state):\n",
    "    return circ(gate_list, wire_list, param_list, state)\n",
    "\n",
    "output = is_particle_preserving(circuit, n)\n",
    "\n",
    "if output:\n",
    "  print(\"Circuit is particle preserving!\")\n",
    "else:\n",
    "  print(\"Circuit is not particle preserving\")"
   ],
   "metadata": {
    "id": "FONnVWhBc54q"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "Testing for 2.in"
   ],
   "metadata": {
    "id": "ALs9YrVrd9Nb"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "inputs = \"4;DoubleExcitation;0,1,2,3;0.732;SingleExcitation;0,1;1.0\".split(\";\")\n",
    "gate_list = []\n",
    "wire_list = []\n",
    "param_list = []\n",
    "i = 1\n",
    "\n",
    "while i < len(inputs):\n",
    "    gate_obj = getattr(qml, str(inputs[i]))\n",
    "    gate_wires = gate_obj.num_wires\n",
    "    input_wires = list(map(int, str(inputs[i + 1]).split(\",\")))\n",
    "    gate_list.append(str(inputs[i]))\n",
    "    wire_list.append(input_wires)\n",
    "    if \"non_parametric_ops\" not in gate_obj.__module__.split(\".\"):\n",
    "        input_params = list(map(float, str(inputs[i + 2]).split(\",\")))\n",
    "        param_list.append(input_params)\n",
    "        i += 1\n",
    "    i += 2\n",
    "\n",
    "wire_list = np.array(wire_list, dtype=object)\n",
    "param_list = np.array(param_list, dtype=object)\n",
    "\n",
    "n = int(inputs[0])\n",
    "dev = qml.device(\"default.qubit\", wires=n)\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def circ(gate_list, wire_list, param_list, state):\n",
    "    qml.BasisState(np.array(state), wires=range(n))\n",
    "    j = 0\n",
    "    for i in range(len(gate_list)):\n",
    "        gate = getattr(qml, str(gate_list[i]))\n",
    "        if \"non_parametric_ops\" not in gate.__module__.split(\".\"):\n",
    "            gate(*param_list[j], wires=[int(w) for w in wire_list[i]])\n",
    "            j += 1\n",
    "        else:\n",
    "            gate(wires=[int(w) for w in wire_list[i]])\n",
    "    return qml.state()\n",
    "\n",
    "def circuit(state):\n",
    "    return circ(gate_list, wire_list, param_list, state)\n",
    "\n",
    "output = is_particle_preserving(circuit, n)\n",
    "\n",
    "if output:\n",
    "  print(\"Circuit is particle preserving!\")\n",
    "else:\n",
    "  print(\"Circuit is not particle preserving\")"
   ],
   "metadata": {
    "id": "mc4tkrkrd_FM"
   },
   "execution_count": null,
   "outputs": []
  }
 ]
}