QuantumRL.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "QuantumRL.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "NV8sEgIgZisp",
        "hnWqxby5ZfY_",
        "kfmGXb2TZWpw"
      ],
      "authorship_tag": "ABX9TyOMWXiACS6pexskr7ftWpzs",
      "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/francescomontagna/Quantum-Reinforcement-Learning/blob/main/QuantumRL.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eNsunVDOmIM2"
      },
      "source": [
        "# Google QuantumAI"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iDU__H-6mNf9"
      },
      "source": [
        "## Install"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_YQgeiVZmK4_",
        "outputId": "5e4c0cbb-9166-4104-d226-eb3b0e77f04c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "try:\n",
        "    import cirq\n",
        "except ImportError:\n",
        "    print(\"installing cirq...\")\n",
        "    !pip install --quiet cirq\n",
        "    print(\"installed cirq.\")"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "installing cirq...\n",
            "\u001b[K     |████████████████████████████████| 1.5MB 7.8MB/s \n",
            "\u001b[K     |████████████████████████████████| 389kB 34.5MB/s \n",
            "\u001b[K     |████████████████████████████████| 1.3MB 35.9MB/s \n",
            "\u001b[?25hinstalled cirq.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AQ05rJZRmPcL"
      },
      "source": [
        "## Imports"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ng8kY2AmmXQS"
      },
      "source": [
        "import cirq\n",
        "from cirq import Simulator"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D7ywYaaLPmtL"
      },
      "source": [
        "# Imports"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ETGJGzcDIxwC"
      },
      "source": [
        "import time\n",
        "import math\n",
        "import cmath\n",
        "import random\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from matplotlib import cm\n",
        "from functools import reduce\n",
        "from google.colab import files\n",
        "from sklearn.model_selection import ParameterGrid"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BWCQSEmAOUI3"
      },
      "source": [
        "# Introduction \n",
        "\n",
        "## Reward\n",
        "Il principale problema è la formulzione della reward. per ora, l'unica soluzione tale da portare risultati accettabili è stata:\n",
        "- reward = \"grande\" per stato terminal\n",
        "- reward < 0 per stato non terminal  \n",
        "\n",
        "L'aggiunta di reward negativa a punire ogni step che non portasse a uno stato terminale, è stato cruciale. Infatti, ho usato altri tipi di reward, ma tutte fallimentari  \n",
        "- fidelity\n",
        "- fidelity per stato terminale, altrimenti 0\n",
        "- \"grande\" per stato terminale, altrimenti 0  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K_8rsT6Mr7Zy"
      },
      "source": [
        "## Off Policy\n",
        "Sono dovuto ricorrere a un'approccio off policy, in quanto un approccio on policy non garantiva esplorazione sufficiente in uno spazio di ricerca così vasto. I risultati erano fortemente limitati, la matrice dei weight non vedeva mai alcune azioni, il cui valore rimaneva 0 per ogni features. I risultati erano in media peggiori di un' approccio Random.  \n",
        "Andando a usare una bahaviour policy completamente randomica, e una target policy completamente greedy, i risultati sono notevolmente migliorati. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t-LCGYpUPpTm"
      },
      "source": [
        "# Quantum Setup"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NV8sEgIgZisp"
      },
      "source": [
        "### Qubit"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DjboXlFWG5EK"
      },
      "source": [
        "class Qubit:\n",
        "  def __init__(self, amplitudes):\n",
        "    \"\"\"\n",
        "    Args:\n",
        "      amplitudes (np.array): amplitudes of the |0>, |1> vectors\n",
        "    \"\"\"\n",
        "    error = \"Error: sum of squared amplitudes must be = 1\"\n",
        "    assert math.isclose(reduce(lambda a, b: a+b, map(lambda a: abs(a)**2, amplitudes)), 1, rel_tol = 1e-2), error\n",
        "    self._amplitudes = amplitudes\n",
        "\n",
        "  def qubit(self):\n",
        "    return self._amplitudes\n",
        "    \n",
        "\n",
        "class Basis(Qubit):\n",
        "  def __init__(self, index):\n",
        "    \"\"\"\n",
        "    Z operator Basis\n",
        "    Args:\n",
        "      index: index of the position = 1\n",
        "    \"\"\"\n",
        "    amplitudes = np.zeros((2, ))\n",
        "    amplitudes[index] += 1\n",
        "    super().__init__(amplitudes)"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hnWqxby5ZfY_"
      },
      "source": [
        "### Quantum State"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yRBaWNuZyhgp"
      },
      "source": [
        "class QuantumState:\n",
        "  def __init__(self, amplitudes): \n",
        "\n",
        "    # We assume computational basis\n",
        "    self._basis = {\n",
        "        '00': [Basis(0), Basis(0)],\n",
        "        '01': [Basis(0), Basis(1)],\n",
        "        '10': [Basis(1), Basis(0)],\n",
        "        '11': [Basis(1), Basis(1)],\n",
        "    }\n",
        "\n",
        "    a1, a2, a3, a4 = amplitudes\n",
        "    self._amplitudes = {\n",
        "        '00': a1,\n",
        "        '01': a2,\n",
        "        '10': a3,\n",
        "        '11': a4\n",
        "    }\n",
        "    \n",
        "    self._keys = list(self._basis.keys())\n",
        "\n",
        "    error = \"Error: sum of squared amplitudes must be = 1\"\n",
        "    val = reduce(lambda a, b: a+b, map(lambda a: abs(a)**2, amplitudes))\n",
        "    assert math.isclose(val, 1, rel_tol = 1e-3), error + f\" instead is {val}\"\n",
        "\n",
        "  def get_amplitudes(self):\n",
        "    return np.array(list(self._amplitudes.values()))\n",
        "\n",
        "  def get_features(self):\n",
        "    real = np.real(list(self.get_amplitudes()))\n",
        "    imag = np.imag(list(self.get_amplitudes()))\n",
        "    return np.concatenate((real, imag))\n",
        "\n",
        "  def apply_gate(self, gate, inplace = False):\n",
        "    updated_amplitudes = gate.apply(self)\n",
        "    if inplace:\n",
        "      self._amplitudes = updated_amplitudes\n",
        "      return None\n",
        "\n",
        "    return QuantumState(list(updated_amplitudes.values()))\n",
        "\n",
        "  def fidelity_score(self, other):\n",
        "    # Fidelity implementation from paper\n",
        "    \"\"\"\n",
        "    Args:\n",
        "      other (QuantumState): measure the fidelity between self and another quantum state\n",
        "    Return:\n",
        "      fidelity (float): fidelity score between [0, 1]\n",
        "    \"\"\"\n",
        "    # Inner product can be computed in terms of matrix representation. Page 67 Nielsen-Chuang\n",
        "    return np.square(abs(np.matmul(np.conj(self.get_amplitudes()), other.get_amplitudes())))"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rboUEAK3ZbWt"
      },
      "source": [
        "### Quantum Gates"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-HOc4Ouiockr"
      },
      "source": [
        "class QuantumGate:\n",
        "  def __init__(self, name, unitary, target):\n",
        "    \"\"\"\n",
        "    Args: \n",
        "      unitary: 2x2 unitary operator\n",
        "      target: 0 or 1 to denote the qubit the matrix is acting on\n",
        "    \"\"\"\n",
        "    self._name = name\n",
        "    self._U = unitary.flatten()\n",
        "    self._target = target\n",
        "\n",
        "\n",
        "  def apply(self, quantum_state):\n",
        "    \"\"\"\n",
        "    Args:\n",
        "      quantum_state (QuantumState): quantum state to which apply the quantum operator\n",
        "    Return:\n",
        "      updated (dict): didctionary with updated amplitudes\n",
        "    \"\"\"\n",
        "    # Directly implement update rule on the amplitudes for a 2 qubits case. \n",
        "    # NOTE: This approach is not scalable! Refine or use qiskit for more than 2 qubits\n",
        "    a_00, a_01, a_10, a_11 = quantum_state.get_amplitudes()\n",
        "    updated = dict()\n",
        "\n",
        "    if self._target == 0:\n",
        "      updated['00'] = self._U[0]*a_00 + self._U[1]*a_10\n",
        "      updated['01'] = self._U[0]*a_01 + self._U[1]*a_11\n",
        "      updated['10'] = self._U[2]*a_00 + self._U[3]*a_10\n",
        "      updated['11'] = self._U[2]*a_01 + self._U[3]*a_11\n",
        "\n",
        "    else:\n",
        "      updated['00'] = self._U[0]*a_00 + self._U[1]*a_01\n",
        "      updated['01'] = self._U[2]*a_00 + self._U[3]*a_01\n",
        "      updated['10'] = self._U[0]*a_10 + self._U[1]*a_11\n",
        "      updated['11'] = self._U[2]*a_10 + self._U[3]*a_11\n",
        "\n",
        "    # Check if amplitudes still satisfy condition\n",
        "    normalization = reduce(lambda a, b: a+b, map(lambda a: abs(a)**2, updated.values()))\n",
        "    error = f\"Error: sum of squared amplitudes must be = 1.\\n Amplitudes: {list(updated.values())}, summing up to {normalization}\"\n",
        "    assert math.isclose(normalization, 1, rel_tol = 1e-2), error\n",
        "    \n",
        "    return updated\n",
        "\n",
        "\n",
        "class CNOT(QuantumGate):\n",
        "  def __init__(self, control):\n",
        "    \"\"\"\n",
        "    Args:\n",
        "      control (int): if 0, first qubit is the control, else second\n",
        "    Return:\n",
        "      result (QuantumState): quantum state with amplitudes modified\n",
        "    \"\"\"\n",
        "    self._control = control\n",
        "    super().__init__('cnot', np.array([[0, 1], [1, 0]]), 1-control)\n",
        "\n",
        "\n",
        "  def apply(self, quantum_state):\n",
        "    \"\"\"\n",
        "    Args:\n",
        "      state (QuantumState): quantum state to which apply the quantum operator\n",
        "    Return:\n",
        "      result (QuantumState): quantum state with amplitudes modified\n",
        "    \"\"\"\n",
        "    # Directly implement update rule on the amplitudes for a 2 qubits case. \n",
        "    # NOTE: This approach is not scalable! Refine or use qiskit for more than 2 qubits\n",
        "    a_00, a_01, a_10, a_11 = quantum_state.get_amplitudes()\n",
        "    updated = dict()\n",
        "\n",
        "    if self._control == 0: # Then control = 1st: if 1st qubit == 1, flip 2nd qubit.\n",
        "      updated['00'] = a_00\n",
        "      updated['01'] = a_01\n",
        "      updated['10'] = self._U[0]*a_10 + self._U[1]*a_11\n",
        "      updated['11'] = self._U[2]*a_10 + self._U[3]*a_11\n",
        "\n",
        "    if self._control == 1: # Then control = 2nd: if 2nd qubit == 1, flip 1st qubit.\n",
        "      updated['00'] = self._U[0]*a_00 + self._U[1]*a_10\n",
        "      updated['01'] = self._U[0]*a_01 + self._U[1]*a_11\n",
        "      updated['10'] = a_10\n",
        "      updated['11'] = a_11\n",
        "\n",
        "    # Check if amplitudes still satisfy condition\n",
        "    normalization = reduce(lambda a, b: a+b, map(lambda a: abs(a)**2, updated.values()))\n",
        "    error = f\"Error: sum of squared amplitudes must be = 1.\\n Amplitudes: {list(updated.values())}, summing up to {normalization}\"\n",
        "    assert math.isclose(normalization, 1, rel_tol = 1e-2), error\n",
        "    \n",
        "    return updated"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kfmGXb2TZWpw"
      },
      "source": [
        "### Gates List"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pus5TovHiETW"
      },
      "source": [
        "class Gates:\n",
        "  def __init__(self):\n",
        "    gates = dict()\n",
        "    self._num_gates = 0\n",
        "\n",
        "    # Useful\n",
        "    targets = [0, 1]\n",
        "    j = 1j # complex unit\n",
        "\n",
        "    ########### CNOT ###########\n",
        "    gates['CNOT'] = CNOT(control = 0)\n",
        "    self._num_gates += 1\n",
        "\n",
        "    ########### Rotations ###########\n",
        "    angles_names = ['pi', '2pi/3', 'pi/2', 'pi/3', 'pi/4']\n",
        "    angles_values = (math.pi / 2) * np.array([1, 2/3, 1/2, 1/3, 1/4])\n",
        "    angles = {k:v for k,v in zip(angles_names, angles_values)}\n",
        "\n",
        "    # Rx\n",
        "    for name, theta in angles.items():\n",
        "      for t in targets:\n",
        "        key = 'Rx' + str(t) + '(' + name + ')'\n",
        "        gates[key] = QuantumGate(key, np.array([[math.cos(theta), -j*math.sin(theta)],\n",
        "                                                      [-j*math.sin(theta), math.cos(theta)]]), t)\n",
        "        self._num_gates += 1\n",
        "        \n",
        "    # Ry\n",
        "    for name, theta in angles.items():\n",
        "      for t in targets:\n",
        "        key = 'Ry' + str(t) + '(' + name + ')'\n",
        "        gates[key] = QuantumGate(key, np.array([[math.cos(theta), -math.sin(theta)],\n",
        "                                                      [math.sin(theta), math.cos(theta)]]), t)\n",
        "        self._num_gates += 1\n",
        "\n",
        "    # Rz\n",
        "    for name, theta in angles.items():\n",
        "      for t in targets:\n",
        "        key = 'Rz' + str(t) + '(' + name + ')'\n",
        "        gates[key] = QuantumGate(key, np.array([[cmath.exp(-j*theta), 0],\n",
        "                                                      [0, cmath.exp(j*theta)]]), t)\n",
        "        self._num_gates += 1\n",
        "\n",
        "    # Hadamard\n",
        "    # gates['H0'] = QuantumGate('Hadamard_0', math.sqrt(1/2)*np.array([[1, 1], [-1, 1]]), 0)\n",
        "    # gates['H1'] = QuantumGate('Hadamard_1', math.sqrt(1/2)*np.array([[1, 1], [-1, 1]]), 1)\n",
        "\n",
        "    self._keys = list(gates.keys())\n",
        "    self._gates = list(gates.values())\n",
        "\n",
        "  def num_gates(self):\n",
        "    return self._num_gates"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EQvWLKKRgZR9"
      },
      "source": [
        "#### Google Gates"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0a4R9ebGj2rl"
      },
      "source": [
        "class GoogleGates: \n",
        "  def __init__(self, keys = list()):\n",
        "    PI = math.pi\n",
        "    self._keys = keys\n",
        "    self._gates = [\n",
        "                  (cirq.CNOT, None),\n",
        "                  (cirq.rx(PI), cirq.I),\n",
        "                  (cirq.I, cirq.rx(PI)),\n",
        "                  (cirq.rx(2*PI/3), cirq.I),\n",
        "                  (cirq.I, cirq.rx(2*PI/3)),\n",
        "                  (cirq.rx(PI/2), cirq.I),\n",
        "                  (cirq.I, cirq.rx(PI/2)),\n",
        "                  (cirq.rx(PI/3), cirq.I),\n",
        "                  (cirq.I, cirq.rx(PI/3)),\n",
        "                  (cirq.rx(PI/4), cirq.I),\n",
        "                  (cirq.I, cirq.rx(PI/4)),\n",
        "                  (cirq.ry(PI), cirq.I),\n",
        "                  (cirq.I, cirq.ry(PI)),\n",
        "                  (cirq.ry(2*PI/3), cirq.I),\n",
        "                  (cirq.I, cirq.ry(2*PI/3)),\n",
        "                  (cirq.ry(PI/2), cirq.I),\n",
        "                  (cirq.I, cirq.ry(PI/2)),\n",
        "                  (cirq.ry(PI/3), cirq.I),\n",
        "                  (cirq.I, cirq.ry(PI/3)),\n",
        "                  (cirq.ry(PI/4), cirq.I),\n",
        "                  (cirq.I, cirq.ry(PI/4)),\n",
        "                  (cirq.rz(PI), cirq.I),\n",
        "                  (cirq.I, cirq.rz(PI)),\n",
        "                  (cirq.rz(2*PI/3), cirq.I),\n",
        "                  (cirq.I, cirq.rz(2*PI/3)),\n",
        "                  (cirq.rz(PI/2), cirq.I),\n",
        "                  (cirq.I, cirq.rz(PI/2)),\n",
        "                  (cirq.rz(PI/3), cirq.I),\n",
        "                  (cirq.I, cirq.rz(PI/3)),\n",
        "                  (cirq.rz(PI/4), cirq.I),\n",
        "                  (cirq.I, cirq.rz(PI/4)),\n",
        "                  # (cirq.H, cirq.I),\n",
        "                  # (cirq.I, cirq.H),\n",
        "    ]\n",
        "\n",
        "\n",
        "  def num_gates(self):\n",
        "    return len(self._gates)"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iQJvflImPuhP"
      },
      "source": [
        "# RL Setup"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aflbZWf75E7C"
      },
      "source": [
        "## Environment"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bL6bfPeCJSbl"
      },
      "source": [
        "class Environment:\n",
        "  def __init__(self, initial_state, target_state,\n",
        "               tolerance, negative_reward, positive_reward, discount = 0):\n",
        "    \"\"\"\n",
        "    Args:\n",
        "      initial_state (QuantumState): initial state of the system\n",
        "      target_state (QuantumState): target state of the system\n",
        "      tolerance (float): tolerance in terms of fidelity score\n",
        "    \"\"\"\n",
        "    self._initial_state = initial_state\n",
        "    self._target_state = target_state\n",
        "\n",
        "    self._tolerance = tolerance # tolerance in terms of fidelity between\n",
        "\n",
        "    self._quantum_gates, self._keys, self._num_gates = self.gates_set()\n",
        "\n",
        "    self._terminal_fidelity = 0 # used to retrieve the info at the end of an episode\n",
        "    self._terminal_state = None # used to retrieve the info at the end of an episode\n",
        "\n",
        "    self._negative_reward = negative_reward\n",
        "    self._positive_reward = positive_reward\n",
        "    self._discount = discount\n",
        "    \n",
        "    # Used to initialize Environment instance from scratch.\n",
        "    self.reset() \n",
        "\n",
        "    \n",
        "  def gates_set(self):\n",
        "    \"\"\"\n",
        "    Returns:\n",
        "      gates._gates (List[QuantumGate]): return the list with available QuantumGate objects\n",
        "      gates._keys (Dict[String: Int]): dictionary mapping a gate to its action index\n",
        "      gates.num_gates() (int): number of available gates (actions)\n",
        "    \"\"\"\n",
        "    gates = Gates()\n",
        "    return gates._gates, gates._keys, gates.num_gates()\n",
        "\n",
        "\n",
        "  def step(self, action):\n",
        "    \"\"\"\n",
        "    Given a gate, apply it to self._state.\n",
        "    Set the reward, resulting state and discount.\n",
        "    Return these values, along with the information if the terminal state has been reached\n",
        "    Args:\n",
        "      action (int): action index to select a QuantumGate\n",
        "\n",
        "    Return:\n",
        "      reward, discount, next_state features, terminal\n",
        "    \"\"\"\n",
        "    # Get and apply action. next_state is a QuantumState\n",
        "    gate = self._quantum_gates[action]\n",
        "    next_state = self._state.apply_gate(gate)\n",
        "\n",
        "    # Compare new state and target\n",
        "    fidelity = next_state.fidelity_score(self._target_state)\n",
        "\n",
        "    # Assign reward based on state and fidelity\n",
        "    terminal = self.is_terminal(fidelity)\n",
        "\n",
        "    # Terminal state\n",
        "    if terminal:\n",
        "      reward = self._positive_reward\n",
        "      discount = 0.\n",
        "      self._terminal_fidelity = fidelity\n",
        "      self._terminal_state = next_state\n",
        "      self.reset()\n",
        "    else:\n",
        "      reward = self._negative_reward\n",
        "      discount = self._discount\n",
        "      self._state = next_state\n",
        "\n",
        "    # Return the features, not the state itself\n",
        "    return reward, discount, self.get_obs(), terminal\n",
        "\n",
        "\n",
        "  def is_terminal(self, fidelity):\n",
        "    \"\"\"\n",
        "    Check if, by a level of self.tolerance, state is terminal\n",
        "    \"\"\"\n",
        "    if fidelity > (1 - self._tolerance):\n",
        "      return True\n",
        "\n",
        "    return False\n",
        "\n",
        "\n",
        "  def get_obs(self):\n",
        "    return self._state.get_features()\n",
        "\n",
        "\n",
        "  def reset(self):\n",
        "    self._state = self._initial_state"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I5ZoAqcy3qkH"
      },
      "source": [
        "## Agent"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hWp0UZ7q6VVF"
      },
      "source": [
        "class ReplayBuffer(object):\n",
        "\n",
        "  def __init__(self):\n",
        "    self.buffer = []\n",
        "  \n",
        "  def append_transition(self, transition):\n",
        "    \"\"\"\n",
        "    Args:\n",
        "      transition (tuple): (state, action, reward, discount, next state)\n",
        "    \"\"\"\n",
        "    self.buffer.append(transition)\n",
        "\n",
        "  def sample_transition(self):\n",
        "    return random.choice(self.buffer)\n",
        "\n",
        "  def clear(self):\n",
        "    self.buffer = []"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "De-sHIvHwKra"
      },
      "source": [
        "# Least Square TD Agent: action value function approximation\n",
        "# implemented with gradient descent.\n",
        "class LSTDAgent:\n",
        "  def __init__(self, number_of_actions, number_of_features,\n",
        "      initial_state, step_size, num_offline_updates, eps = 1.):\n",
        "    \"\"\"\n",
        "    Args:\n",
        "      initial_state: it is a feature vector!\n",
        "    \"\"\"\n",
        "    self._number_of_actions = number_of_actions\n",
        "    self._number_of_features = number_of_features\n",
        "    self._W = np.zeros((number_of_actions, number_of_features), dtype = np.float16)\n",
        "    \n",
        "    self._step_size = step_size\n",
        "    self._initial_state = initial_state\n",
        "\n",
        "    self._num_offline_updates = num_offline_updates\n",
        "    self._replay_buffer = ReplayBuffer() # supervised dataset\n",
        "    self._step = 0\n",
        "\n",
        "    self._eps = eps # By default, fully random behavioural policy\n",
        "\n",
        "    # St self._state to initial state and pick an action randomly\n",
        "    self.reset(True)\n",
        "\n",
        "\n",
        "  def behaviour_policy(self, state = None):\n",
        "    greedy = np.random.choice([True, False], p=[1-self._eps, self._eps])\n",
        "    if greedy:\n",
        "      return np.argmax(self.q(state))\n",
        "    return random.choice(range(self._number_of_actions))\n",
        "\n",
        "\n",
        "  def q(self, state):\n",
        "    \"\"\"\n",
        "    Args:\n",
        "      state (list): list of the amplitudes := features of the state\n",
        "    \"\"\"\n",
        "    return np.matmul(self._W, state)\n",
        "\n",
        "\n",
        "  def step(self, reward, discount, next_state):\n",
        "    \"\"\"\n",
        "    Args:\n",
        "      next_state (list): list of the amplitude: these are already features, not a QuantumState instance\n",
        "      terminal (boolean): if next_state is the terminal state\n",
        "    \"\"\"\n",
        "    s = self._state\n",
        "    a = self._action\n",
        "    r = reward\n",
        "    next_s = next_state\n",
        "    g = discount\n",
        "\n",
        "    # print(f\"State: {s}\")\n",
        "    # print(f\"Next State: {next_s}\")\n",
        "    # print()\n",
        "    self._W[a] += self._step_size * (r + g * np.max(self.q(next_s)) - self.q(s)[a]) * s\n",
        "\n",
        "    # Experience replay\n",
        "    self._replay_buffer.append_transition((s, a, r, g, next_s))\n",
        "    for _ in range(self._num_offline_updates):\n",
        "      s, a, r, g, next_s = self._replay_buffer.sample_transition()\n",
        "      self._W[a] += self._step_size * (r + g * np.max(self.q(next_s)) - self.q(s)[a]) * s\n",
        "\n",
        "    next_a = self.behaviour_policy(next_s)\n",
        "    self._action = next_a\n",
        "    self._state = next_s\n",
        "    self._step += 1\n",
        "\n",
        "    return next_a\n",
        "\n",
        "\n",
        "  def inference(self, reward, discount, next_state):\n",
        "    s = self._state\n",
        "    a = self._action\n",
        "    r = reward\n",
        "    next_s = next_state\n",
        "    g = discount\n",
        "\n",
        "    next_a = np.argmax(self.q(next_s))\n",
        "    self._action = next_a\n",
        "    self._state = next_s\n",
        "\n",
        "    return next_a\n",
        "\n",
        "\n",
        "  def reset(self, random = False, W = None):\n",
        "    self._state = self._initial_state\n",
        "    self._action = self.behaviour_policy(self._state)\n",
        "\n",
        "\n",
        "    self._replay_buffer.clear()"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C5_vQxz7Ke2s"
      },
      "source": [
        "# Helper Functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dSwKia38JvwL"
      },
      "source": [
        "def compare_circuits(circuit_gates, final_state, target_state, path = None):\n",
        "  \"\"\"\n",
        "  Compare results obtained by google gates vs my custom gates implementation\n",
        "  Args:\n",
        "    circuit_gates (List[int]): indices of the gates in the circuit defined by the agent\n",
        "    final_state (QuantumState): terminal state reached by the agent\n",
        "    target_state (QuantumState): target state of TD agent\n",
        "  \"\"\"\n",
        "  my_gates = Gates()\n",
        "  google_gates = GoogleGates(my_gates._keys)\n",
        "\n",
        "  # Google initialization\n",
        "  q0 = cirq.NamedQubit('q0')\n",
        "  q1 = cirq.NamedQubit('q1')\n",
        "  circuit = cirq.Circuit()\n",
        "  def basic_circuit(u0, u1):\n",
        "    if (u1 is not None):\n",
        "      yield u0(q0), u1(q1)\n",
        "    else:\n",
        "      yield u0(q0, q1)\n",
        "\n",
        "  # Create the circuit with both Google API and my implementation\n",
        "  q = QuantumState(np.array([1, 0, 0, 0]))\n",
        "  for idx in circuit_gates:\n",
        "    q = q.apply_gate(my_gates._gates[idx])\n",
        "    circuit.append(basic_circuit(*google_gates._gates[idx]))\n",
        "\n",
        "  # Simulate Google circuit - oracle\n",
        "  simulator = Simulator()\n",
        "  google_result = simulator.simulate(circuit, qubit_order=[q0, q1])\n",
        "\n",
        "  # Check coherence between approximate terminal states\n",
        "  assert np.all(np.around(q.get_amplitudes(), 3) == np.around(final_state.get_amplitudes(), 3)),\\\n",
        "   f\"Unexpected terminal state: got {np.around(q.get_amplitudes(), 3)} rather than {np.around(final_state.get_amplitudes(), 3)}\"\n",
        "\n",
        "  # Check coherence between Google result and mine\n",
        "  assert np.allclose(q.get_amplitudes(), np.array(google_result.final_state_vector), atol = 1e-8),\\\n",
        "   f\"Unexpected terminal state: got {np.around(q.get_amplitudes(), 3)} rather than {np.around(google_result.final_state_vector, 3)}\"\n",
        "\n",
        "  print(f\"Approximate state: {np.around(final_state.get_amplitudes(), 3)}\")\n",
        "  print(f\"Target state: {np.around(target_state.get_amplitudes(), 3)}\")\n",
        "  print(f\"Fidelity score: {target_state.fidelity_score(final_state)}. Number of gates: {len(circuit_gates)}\")\n",
        "\n",
        "  print(\"\")\n",
        "  print(circuit)\n",
        "\n",
        "  if path is not None:\n",
        "    logs(final_state, target_state, circuit_gates, circuit, path)"
      ],
      "execution_count": 42,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WyWWqvKkQSMj"
      },
      "source": [
        "def get_quantum_state(tolerance, seed, i):\n",
        "  \"\"\"\n",
        "  Get a feasible set of amplitudes of a quantum state, \n",
        "  by applying a random number of random gates to the initial state |00>\n",
        "\n",
        "  Return:\n",
        "    amplitudes (np.array): list of new state amplitudes\n",
        "  \"\"\"\n",
        "  random.seed(seed + i)\n",
        "  np.random.seed(seed + i)\n",
        "\n",
        "  gates = GoogleGates()\n",
        "\n",
        "  # Circuit initialization\n",
        "  q0 = cirq.NamedQubit('q0')\n",
        "  q1 = cirq.NamedQubit('q1')\n",
        "  circuit = cirq.Circuit()\n",
        "  def basic_circuit(u0, u1):\n",
        "    if (u1 is not None):\n",
        "      yield u0(q0), u1(q1)\n",
        "    else:\n",
        "      yield u0(q0, q1)\n",
        "\n",
        "  is_next = True\n",
        "  while is_next:\n",
        "    idx = random.choice(range(gates.num_gates()))\n",
        "    circuit.append(basic_circuit(*gates._gates[idx]))\n",
        "    is_next = np.random.choice([True, False], p=[0.9, 0.1])\n",
        "\n",
        "  simulator = Simulator()\n",
        "  result = simulator.simulate(circuit, qubit_order=[q0, q1])\n",
        "\n",
        "  amplitudes = result.final_state_vector\n",
        "\n",
        "  # Check correctness of the new state\n",
        "  error = \"Error: sum of squared amplitudes must be = 1\"\n",
        "  val = reduce(lambda a, b: a+b, map(lambda a: abs(a)**2, amplitudes))\n",
        "  assert math.isclose(val, 1, rel_tol = 1e-2), error + f\" instead is {val}\"\n",
        "\n",
        "  # If I am equal to the initial state\n",
        "  if QuantumState(amplitudes).fidelity_score(QuantumState(np.array([1, 0, 0, 0]))) > (1-tolerance):\n",
        "    get_quantum_state(tolerance, seed, i*100)\n",
        "\n",
        "  return amplitudes"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZBEHNVrNmria"
      },
      "source": [
        "def logs(final_state, target_state, circuit_gates, circuit, path):\n",
        "  \"\"\"\n",
        "  extra: any extra information I want to include in the logging\n",
        "  \"\"\"\n",
        "  with open(path, 'a+') as f:\n",
        "    f.write(f\"Approximate state: {np.around(final_state.get_amplitudes(), 3)}\\n\")\n",
        "    f.write(f\"Target state: {np.around(target_state.get_amplitudes(), 3)}\\n\")\n",
        "    f.write(f\"Fidelity score: {target_state.fidelity_score(final_state)}. Number of gates: {len(circuit_gates)}\\n\")\n",
        "    f.write(f\"Gates List: \")\n",
        "    f.write(f\"{circuit_gates}\\n\")\n",
        "    f.write(f\"{circuit}\\n\\n\")"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OFL1yPnM06xH"
      },
      "source": [
        "# Experiment Facade\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DfMBR8Ws0sqy"
      },
      "source": [
        "# Facade class to run experiment\n",
        "class Experiment:\n",
        "  def __init__(self, start_state, target_state, tolerance, number_of_episodes,\n",
        "               step_size, num_offline_updates, negative_reward, positive_reward,\n",
        "               discount, eps = None):\n",
        "\n",
        "    self._env = Environment(QuantumState(start_state), QuantumState(target_state),\n",
        "                            tolerance, negative_reward, positive_reward, discount)\n",
        "\n",
        "    number_of_actions = len(self._env._keys)\n",
        "    initial_features = self._env.get_obs()\n",
        "\n",
        "    self._agent = LSTDAgent(number_of_actions, len(initial_features), initial_features,\n",
        "                            step_size, num_offline_updates, eps)\n",
        "    \n",
        "    self._number_of_episodes = number_of_episodes\n",
        "\n",
        "\n",
        "  def run_experiment(self):\n",
        "    \"\"\"\n",
        "    Run episodes, gathering statistics and updating user on console.\n",
        "    \"\"\"\n",
        "    min_steps = -1\n",
        "    min_gates = []\n",
        "    min_terminal_state = None\n",
        "    for episode in range(self._number_of_episodes):\n",
        "        self.run_episode()\n",
        "        gates, terminal_state = self.run_inference(episode)\n",
        "        if min_steps == -1 or len(gates) < min_steps:\n",
        "            min_steps = len(gates)\n",
        "            min_gates = gates\n",
        "            min_terminal_state = terminal_state\n",
        "\n",
        "    return min_gates, min_terminal_state\n",
        "\n",
        "\n",
        "  def run_episode(self):\n",
        "    \"\"\"\n",
        "    Run a single episode.\n",
        "    At the beginning of an episode we must guarantee\n",
        "    - initial state in the environment\n",
        "    - initial state in the agent\n",
        "    \"\"\"\n",
        "    terminal = False\n",
        "    action = self._agent._action\n",
        "    while not terminal:\n",
        "      reward, discount, next_s, terminal = self._env.step(action)\n",
        "      action = self._agent.step(reward, discount, next_s)\n",
        "\n",
        "    # Add a reset step below, to take first action\n",
        "    self._agent.reset()\n",
        "\n",
        "\n",
        "  def run_inference(self, episode):\n",
        "    \"\"\"\n",
        "    Run an episode using the optimal policy learned\n",
        "    \"\"\"\n",
        "    terminal = False\n",
        "    action = self._agent._action\n",
        "    gates = []\n",
        "    while not terminal and len(gates) <= 1000:\n",
        "      gates.append(action)\n",
        "      reward, discount, next_s, terminal = self._env.step(action)\n",
        "      action = self._agent.inference(reward, discount, next_s)\n",
        "\n",
        "    if not terminal:\n",
        "      return gates, self._env._state\n",
        "\n",
        "    max_gates = 20\n",
        "    if len(gates) < max_gates:\n",
        "      print(f\"Episode {episode}: inference completed in {len(gates)} steps. Fidelity score: {self._env._terminal_fidelity}\")\n",
        "\n",
        "    return gates, self._env._terminal_state\n",
        "\n",
        "  \n",
        "  def q_values(self):\n",
        "    \"\"\"\n",
        "    The function should plot, in a [0, 1] complex plane, the value function\n",
        "    on the z axis, for each of the 4 value of amplitude.\n",
        "    In order to get reasonable values and understand the effect of the amplitude\n",
        "    under analysis on the overall q_values, the remaining amplitudes values will \n",
        "    be set to the target amplitudes.\n",
        "    \"\"\"\n",
        "    fig, ax = plt.subplots(subplot_kw={\"projection\": \"3d\"})\n",
        "\n",
        "    state = self._env._target_state\n",
        "    features = state.get_features()\n",
        "    x = np.linspace(0, 1, num=100)\n",
        "    y = np.linspace(0, 1, num=100)\n",
        "    grid = np.meshgrid\n",
        "    q = []\n",
        "    for i in x:\n",
        "      row = []\n",
        "      for k in y:\n",
        "        features[0] = i\n",
        "        features[0] = k\n",
        "        row.append(self._agent.q(features))\n",
        "      \n",
        "      q.append(row)\n",
        "\n",
        "    q = np.array(q)\n",
        "    surf = ax.plot_surface(x, y, np.squeeze(q[:, :, 0]), cmap=cm.coolwarm,\n",
        "                       linewidth=0, antialiased=False)\n",
        "    \n",
        "    # Add a color bar which maps values to colors.\n",
        "    fig.colorbar(surf, shrink=0.5, aspect=5)\n",
        "\n",
        "    plt.show()"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2YKa4MYQ0tUp"
      },
      "source": [
        "# Experiment"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UhrdRkT2LaEE"
      },
      "source": [
        "## Random Target States"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3R5nEorB3kgW"
      },
      "source": [
        "TOLERANCE = 0.15\n",
        "TRAINING_EPISODES = 100\n",
        "NUM_OFFLINE_UPDATES = 0 # WAY WORSE IF != 0\n",
        "\n",
        "STEP_SIZE = 0.0001\n",
        "NEG_REWARD = -1.\n",
        "POS_REWARD = 100.\n",
        "DISCOUNT = 0.\n",
        "EPS = 1\n",
        "SEED = 100\n",
        "NUM_EXPERIMENTS = 5\n",
        "PATH = \"logs.txt\""
      ],
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CxfbO_gNpdtC"
      },
      "source": [
        "with open(PATH, \"w+\") as f:\n",
        "  f.write(f\"TOLERANCE: {TOLERANCE}\\n\")\n",
        "  f.write(f\"TRAINING_EPISODES: {TRAINING_EPISODES}\\n\")\n",
        "  f.write(f\"STEP_SIZE: {STEP_SIZE}\\n\")\n",
        "  f.write(f\"NUM_OFFLINE_UPDATES: {NUM_OFFLINE_UPDATES}\\n\")\n",
        "  f.write(f\"SEED: {SEED}\\n\")\n",
        "  f.write(f\"NUM_EXPERIMENTS: {NUM_EXPERIMENTS}\\n\\n\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7b2pDqPiVFxp",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 537
        },
        "outputId": "a81c3bec-d6b3-4452-9a9c-e59d69f49edb"
      },
      "source": [
        "for i in range(NUM_EXPERIMENTS):\n",
        "  start = [1, 0, 0, 0]\n",
        "  target = get_quantum_state(TOLERANCE, SEED, i)\n",
        "\n",
        "  print(f\"Experiment {i}\")\n",
        "\n",
        "  experiment = Experiment(start, target, TOLERANCE, TRAINING_EPISODES, STEP_SIZE,\n",
        "                          NUM_OFFLINE_UPDATES, NEG_REWARD, POS_REWARD, \n",
        "                          DISCOUNT, EPS)\n",
        "  circuit_gates, terminal_state = experiment.run_experiment()\n",
        "  target_state = QuantumState(target)\n",
        "  compare_circuits(circuit_gates, terminal_state, target_state, PATH)\n",
        "  print()\n",
        "\n",
        "  sns.heatmap(experiment._agent._W)\n",
        "  plt.show()\n",
        "  print()\n",
        "  print()   "
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Experiment 0\n",
            "Episode 14: inference completed in 4 steps. Fidelity score: 0.9579772349762904\n",
            "Episode 30: inference completed in 3 steps. Fidelity score: 0.9579772349762904\n",
            "Episode 33: inference completed in 3 steps. Fidelity score: 0.943213935592611\n",
            "Episode 54: inference completed in 3 steps. Fidelity score: 0.8888666522613753\n",
            "Episode 56: inference completed in 9 steps. Fidelity score: 0.9001872175505669\n",
            "Episode 58: inference completed in 13 steps. Fidelity score: 0.9092906748162879\n",
            "Episode 64: inference completed in 3 steps. Fidelity score: 0.9579772349762904\n",
            "Episode 65: inference completed in 4 steps. Fidelity score: 0.9579772349762904\n",
            "Episode 69: inference completed in 9 steps. Fidelity score: 0.8522140042101756\n",
            "Episode 72: inference completed in 5 steps. Fidelity score: 0.9579772349762902\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-45-0d4c80f788ec>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      8\u001b[0m                           \u001b[0mNUM_OFFLINE_UPDATES\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNEG_REWARD\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mPOS_REWARD\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m                           DISCOUNT, EPS)\n\u001b[0;32m---> 10\u001b[0;31m   \u001b[0mcircuit_gates\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mterminal_state\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mexperiment\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_experiment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     11\u001b[0m   \u001b[0mtarget_state\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mQuantumState\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtarget\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m   \u001b[0mcompare_circuits\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuit_gates\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mterminal_state\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_state\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mPATH\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-17-b1712602ae20>\u001b[0m in \u001b[0;36mrun_experiment\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     25\u001b[0m     \u001b[0mmin_terminal_state\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     26\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mepisode\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_number_of_episodes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 27\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_episode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     28\u001b[0m         \u001b[0mgates\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mterminal_state\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_inference\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mepisode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     29\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mmin_steps\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgates\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mmin_steps\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-17-b1712602ae20>\u001b[0m in \u001b[0;36mrun_episode\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     45\u001b[0m     \u001b[0maction\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_agent\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_action\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     46\u001b[0m     \u001b[0;32mwhile\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mterminal\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 47\u001b[0;31m       \u001b[0mreward\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdiscount\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnext_s\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mterminal\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_env\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maction\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     48\u001b[0m       \u001b[0maction\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_agent\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreward\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdiscount\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnext_s\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     49\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-9-40667981aaa8>\u001b[0m in \u001b[0;36mstep\u001b[0;34m(self, action)\u001b[0m\n\u001b[1;32m     53\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     54\u001b[0m     \u001b[0;31m# Compare new state and target\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m     \u001b[0mfidelity\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnext_state\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfidelity_score\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_target_state\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     57\u001b[0m     \u001b[0;31m# Assign reward based on state and fidelity\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-5-95c7ffe9472f>\u001b[0m in \u001b[0;36mfidelity_score\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m     49\u001b[0m     \"\"\"\n\u001b[1;32m     50\u001b[0m     \u001b[0;31m# Inner product can be computed in terms of matrix representation. Page 67 Nielsen-Chuang\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 51\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msquare\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatmul\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_amplitudes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_amplitudes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "id": "LynFoa72p99I",
        "outputId": "b3b7de86-ea59-4d01-8ddf-e8edbd427cd8"
      },
      "source": [
        "files.download(PATH)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "download(\"download_65ffe74a-dae3-4b59-8605-e265d8bb47bd\", \"logs.txt\", 7889)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iuNnRBpQLEpe"
      },
      "source": [
        "## Bell Target States"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hn6FxnB9LLtB"
      },
      "source": [
        "# Bell states amplitudes\n",
        "bell_amplitudes = np.array([[1/math.sqrt(2), 0, 0, 1/math.sqrt(2)], # |00> + |11>\n",
        "                            [0, 1/math.sqrt(2), 1/math.sqrt(2), 0], # |01> + |10>\n",
        "                            [1/math.sqrt(2), 0, 0, -1/math.sqrt(2)], # |00> - |11>\n",
        "                            [0, 1/math.sqrt(2), -1/math.sqrt(2), 0]]) # |01> - |10>\n",
        "bell_dict = {\n",
        "    '|00> + |11>' : bell_amplitudes[0],\n",
        "    '|01> + |10>' : bell_amplitudes[1],\n",
        "    '|00> - |11>' : bell_amplitudes[2],\n",
        "    '|01> - |10>' : bell_amplitudes[3],\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XmkD7aj361y_"
      },
      "source": [
        "### Parameter tuning"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4HsG6MKfQ5GL"
      },
      "source": [
        "TOLERANCE = 0.15\n",
        "TRAINING_EPISODES = 100\n",
        "NUM_OFFLINE_UPDATES = 0 # WAY WORSE IF != 0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7NKF5kmFX30K"
      },
      "source": [
        "params = {'step_size': [0.0001, 0.0005, 0.00005],\n",
        "          'negative_reward' : [0, -1., -5. ,-10.], \n",
        "          'positive_reward' : [1, 50., 80., 100.],\n",
        "          'discount': [0, 0.25, 0.5, 0.75, 0.9]}\n",
        "param_grid = ParameterGrid(params)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UmtpRnrMOqJv"
      },
      "source": [
        "%%time\n",
        "def experiment_logs(logs, circuit_gates, final_state, target_state, params, rep):\n",
        "  logs[rep]['fidelity'].append(target_state.fidelity_score(final_state))\n",
        "  logs[rep]['num_gates'].append(len(circuit_gates))\n",
        "  logs[rep]['params'].append(params)\n",
        "\n",
        "gridsearch_logs = {key:{'params': [], 'fidelity':[], 'num_gates':[]} for key in bell_dict.keys()}\n",
        "\n",
        "for params in  param_grid:\n",
        "  print(params)\n",
        "  step_size = params['step_size']\n",
        "  negative_reward = params['negative_reward']\n",
        "  positive_reward = params['positive_reward']\n",
        "  discount = params['discount']\n",
        "  for rep, bell_state in bell_dict.items():\n",
        "    print(rep)\n",
        "    start = [1, 0, 0, 0]\n",
        "    target = bell_state\n",
        "\n",
        "    experiment = Experiment(start, target, TOLERANCE, TRAINING_EPISODES, step_size, NUM_OFFLINE_UPDATES,\n",
        "                            negative_reward, positive_reward, discount)\n",
        "    \n",
        "    circuit_gates, terminal_state = experiment.run_experiment()\n",
        "\n",
        "    experiment_logs(gridsearch_logs, circuit_gates, terminal_state, QuantumState(target), params, rep)\n",
        "    print()\n",
        "  print()\n",
        "\n",
        "gridsearch_df = pd.DataFrame(gridsearch_logs)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qF5Gafz_Q2aA"
      },
      "source": [
        "path = \"tuning.txt\"\n",
        "\n",
        "with open(path, 'w+') as f:\n",
        "  f.write(\"Arguments \\n\")\n",
        "  f.write(f\"Tolerance: {TOLERANCE} - Training episodes: {TRAINING_EPISODES} - Offline updates: {NUM_OFFLINE_UPDATES}\\n\\n\")\n",
        "\n",
        "  f.write(\"\\t\".join([\"Bell state\", \"parameters\", \"number of gates\", \"fidelity\", \"optimality_type\"]))\n",
        "  f.write(\"\\n\")\n",
        "  for col in gridsearch_df:\n",
        "    f.write(col + \"\\t\")\n",
        "    f.write(f\"{gridsearch_df.loc['params', col][np.argmin(gridsearch_df.loc['num_gates', col])]}\\t\")\n",
        "    f.write(f\"{gridsearch_df.loc['num_gates', col][np.argmin(gridsearch_df.loc['num_gates', col])]}\\t\")\n",
        "    f.write(f\"{gridsearch_df.loc['fidelity', col][np.argmin(gridsearch_df.loc['num_gates', col])]}\\t\")\n",
        "    f.write(\"num_gates \\n\")\n",
        "\n",
        "    f.write(col + \"\\t\")\n",
        "    f.write(f\"{gridsearch_df.loc['params', col][np.argmax(gridsearch_df.loc['fidelity', col])]}\\t\")\n",
        "    f.write(f\"{gridsearch_df.loc['num_gates', col][np.argmax(gridsearch_df.loc['fidelity', col])]}\\t\")\n",
        "    f.write(f\"{gridsearch_df.loc['fidelity', col][np.argmax(gridsearch_df.loc['fidelity', col])]}\\t\")\n",
        "    f.write(\"fidelity \\n\")\n",
        "    f.write(\"\\n\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "id": "uf9YiSkSRvX1",
        "outputId": "b11944a4-b5a9-47d6-f65c-7e8c7d449b86"
      },
      "source": [
        "files.download(path)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "download(\"download_e6f2c375-310a-4c30-8092-283a945e9fb8\", \"tuning.csv\", 29041)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A_Sp4QyeQQwc"
      },
      "source": [
        "### Train"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FWQtqZmJLrpK"
      },
      "source": [
        "TOLERANCE = 0.15\n",
        "TRAINING_EPISODES = 100\n",
        "NUM_OFFLINE_UPDATES = 0 # WAY WORSE IF != 0\n",
        "\n",
        "STEP_SIZE = 0.0001\n",
        "NEG_REWARD = -1.\n",
        "POS_REWARD = 100.\n",
        "DISCOUNT = 0.\n",
        "EPS = 1\n",
        "PATH = 'logs.txt'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D2OFavVsN5HU"
      },
      "source": [
        "with open(PATH, \"w+\") as f:\n",
        "  f.write(f\"TOLERANCE: {TOLERANCE}\\n\")\n",
        "  # f.write(f\"TRAINING_EPISODES: {TRAINING_EPISODES}\\n\")\n",
        "  f.write(f\"STEP_SIZE: {STEP_SIZE}\\n\")\n",
        "  f.write(f\"NUM_OFFLINE_UPDATES: {NUM_OFFLINE_UPDATES}\\n\")\n",
        "  f.write(f\"NEG_REWARD: {NEG_REWARD}\\n\")\n",
        "  f.write(f\"POS_REWARD: {POS_REWARD}\\n\")\n",
        "  f.write(f\"DISCOUNT: {DISCOUNT}\\n\")\n",
        "  f.write(f\"DISCOUNT: {EPS}\\n\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "kijLuLg7N5Kb",
        "outputId": "d7cf7907-b52a-4844-8546-f2fb4106528d"
      },
      "source": [
        "W = None\n",
        "\n",
        "for rep, bell_state in bell_dict.items():\n",
        "  print(\"Bell state: \" +  rep)\n",
        "  start = [1, 0, 0, 0]\n",
        "  target = bell_state\n",
        "\n",
        "  experiment = Experiment(start, target, TOLERANCE, TRAINING_EPISODES, STEP_SIZE,\n",
        "                          NUM_OFFLINE_UPDATES, NEG_REWARD, POS_REWARD, \n",
        "                          DISCOUNT, EPS)\n",
        "  circuit_gates, terminal_state = experiment.run_experiment()\n",
        "  compare_circuits(circuit_gates, terminal_state, QuantumState(target))\n",
        "  print()\n",
        "\n",
        "  sns.heatmap(experiment._agent._W)\n",
        "  plt.show()\n",
        "  print()\n",
        "  print()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Bell state: |00> + |11>\n",
            "Episode 19: inference completed in 10 steps. Fidelity score: 0.8705127018922191\n",
            "Episode 20: inference completed in 13 steps. Fidelity score: 0.9171168834528284\n",
            "Episode 39: inference completed in 2 steps. Fidelity score: 0.9999999999999998\n",
            "Episode 41: inference completed in 2 steps. Fidelity score: 0.9999999999999998\n",
            "Episode 43: inference completed in 2 steps. Fidelity score: 0.9999999999999998\n",
            "Episode 45: inference completed in 2 steps. Fidelity score: 0.9999999999999998\n",
            "Episode 49: inference completed in 2 steps. Fidelity score: 0.9999999999999998\n",
            "Episode 51: inference completed in 2 steps. Fidelity score: 0.9999999999999998\n",
            "Episode 55: inference completed in 2 steps. Fidelity score: 0.8535533905932735\n",
            "Episode 56: inference completed in 2 steps. Fidelity score: 0.9999999999999998\n",
            "Episode 64: inference completed in 2 steps. Fidelity score: 0.9999999999999998\n",
            "Episode 74: inference completed in 3 steps. Fidelity score: 0.9330127018922192\n",
            "Episode 84: inference completed in 3 steps. Fidelity score: 0.9330127018922192\n",
            "Episode 90: inference completed in 13 steps. Fidelity score: 0.8705127018922195\n",
            "Episode 92: inference completed in 2 steps. Fidelity score: 0.9330127018922192\n",
            "Episode 94: inference completed in 2 steps. Fidelity score: 0.9999999999999998\n",
            "Approximate state: [0.707 0.    0.    0.707]\n",
            "Target state: [0.707 0.    0.    0.707]\n",
            "Fidelity score: 0.9999999999999998. Number of gates: 2\n",
            "\n",
            "q0: ───Ry(0.5π)───@───\n",
            "                  │\n",
            "q1: ───I──────────X───\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "Bell state: |01> + |10>\n",
            "Episode 78: inference completed in 7 steps. Fidelity score: 1.0\n",
            "Episode 79: inference completed in 8 steps. Fidelity score: 0.8535533905932735\n",
            "Episode 81: inference completed in 7 steps. Fidelity score: 0.9330127018922194\n",
            "Approximate state: [-0.+0.j     0.+0.707j  0.+0.707j -0.+0.j   ]\n",
            "Target state: [0.    0.707 0.707 0.   ]\n",
            "Fidelity score: 1.0. Number of gates: 7\n",
            "\n",
            "q0: ───Ry(0.5π)───I───────I──────────I──────────I──────────I──────────@───\n",
            "                                                                      │\n",
            "q1: ───I──────────Rx(π)───Ry(0.5π)───Ry(0.5π)───Ry(0.5π)───Ry(0.5π)───X───\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "Bell state: |00> - |11>\n",
            "Episode 29: inference completed in 5 steps. Fidelity score: 1.0\n",
            "Episode 31: inference completed in 6 steps. Fidelity score: 1.0\n",
            "Episode 61: inference completed in 6 steps. Fidelity score: 0.933012701892219\n",
            "Episode 62: inference completed in 6 steps. Fidelity score: 0.9999999999999993\n",
            "Episode 63: inference completed in 6 steps. Fidelity score: 0.9999999999999993\n",
            "Episode 64: inference completed in 8 steps. Fidelity score: 0.933012701892219\n",
            "Episode 66: inference completed in 6 steps. Fidelity score: 0.9999999999999993\n",
            "Episode 67: inference completed in 6 steps. Fidelity score: 0.9999999999999993\n",
            "Episode 69: inference completed in 6 steps. Fidelity score: 0.9999999999999993\n",
            "Episode 70: inference completed in 6 steps. Fidelity score: 0.9999999999999993\n",
            "Episode 71: inference completed in 6 steps. Fidelity score: 0.9999999999999993\n",
            "Episode 74: inference completed in 8 steps. Fidelity score: 0.933012701892219\n",
            "Episode 75: inference completed in 8 steps. Fidelity score: 0.933012701892219\n",
            "Approximate state: [ 0.354+0.612j  0.   +0.j     0.   +0.j    -0.354-0.612j]\n",
            "Target state: [ 0.707  0.     0.    -0.707]\n",
            "Fidelity score: 1.0. Number of gates: 5\n",
            "\n",
            "q0: ───Ry(0.5π)───Ry(π)───I────────────I────────────@───\n",
            "                                                    │\n",
            "q1: ───I──────────I───────Rz(0.667π)───Rz(0.667π)───X───\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "Bell state: |01> - |10>\n",
            "Approximate state: [ 0.159+0.086j -0.7  -0.02j   0.664-0.071j -0.162-0.06j ]\n",
            "Target state: [ 0.     0.707 -0.707  0.   ]\n",
            "Fidelity score: 0.9326294121851983. Number of gates: 33\n",
            "\n",
            "q0: ───I────────────I────────────I────────────I────────────I────────────I───────I────────────I────────────Ry(0.5π)───Ry(0.25π)───Rz(0.5π)───Rz(0.5π)───Rz(0.5π)───I───────Rz(0.667π)───Rz(0.333π)───Rz(0.333π)───I────────────I────────────I────────────I────────────I───────Rz(0.667π)───Rz(0.333π)───I────────────I────────────I────────────I────────────I────────────I───────Rx(0.667π)───Rz(0.667π)───@───\n",
            "                                                                                                                                                                                                                                                                                                                                                                                                          │\n",
            "q1: ───Rx(0.333π)───Rx(0.333π)───Rx(0.333π)───Rx(0.333π)───Rx(0.333π)───Rz(π)───Ry(0.333π)───Ry(0.333π)───I──────────I───────────I──────────I──────────I──────────Rz(π)───I────────────I────────────I────────────Rx(0.333π)───Rx(0.333π)───Rx(0.333π)───Rx(0.333π)───Rz(π)───I────────────I────────────Rx(0.333π)───Rx(0.333π)───Rx(0.333π)───Rx(0.333π)───Rx(0.333π)───Rz(π)───I────────────I────────────X───\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E1SOmLK9O1mJ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "outputId": "3c036b50-ca1a-4e56-87bd-c1ff14630648"
      },
      "source": [
        "files.download(PATH)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "download(\"download_1c46f57c-632d-4e78-8ccc-d7287ba1de22\", \"logs.txt\", 593)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    }
  ]
}