vqls_with_lcu-10Qbits.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# QPoland Global Quantum Hackathon\n",
    "19-Oct-2024 to 27-Oct-2024 (For QML track submission deadline extended till 18-Nov-2024)\n",
    "\n",
    "https://www.qaif.org/contests/qpoland-global-quantum-hackathon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Team name**:  Qudit Creons"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem Statement:\n",
    "### Quantum Machine Learning: Solving Linear Systems of Equations\n",
    "### Re-Implementation of Variational Quantum Linear Solver from paper [Bravo-Prieto et al. (2020)](https://arxiv.org/pdf/1909.05820.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Background\n",
    "\n",
    "Linear systems of equations are fundamental in mathematics and have wide-ranging applications across several fields, including physics, engineering, economics, and computer science. This kind of equation can be found when solving numerically differential equations, analyzing electrical circuits, or performing 3D transformations in computer vision. Additionally, linear systems are critical in statistical analysis, particularly in regression models, which are used to find the best-fit line for data. Their importance lies in their simplicity, versatility, and ability to provide solutions in many practical scenarios.\n",
    "\n",
    "Considering this, solving a linear system that grows in size becomes more difficult using classical computing techniques. In particular, Carlos Bravo-Prieto et al.'s paper \"Variational Quantum Linear Solver\" Ref[1] shows a solution to this problem using quantum machine learning methods.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Detailed Challenge Description\n",
    "\n",
    "In this challenge, your goal is to reproduce the implementation of the quantum algorithm displayed in **the Sec. 2.3 of the paper Ref [1]**, i.e. solve the following system of linear equations:\n",
    " $$\\textbf{A}\\vec{x}= \\vec{0}$$\n",
    "\n",
    " $$A = \\sum_{i=1}^{10} X_i  + 0.1\\sum_{i=1}^{9} Z_i Z_{i+1} +I,$$\n",
    "\n",
    "\n",
    "Where $ X_i$, adn $Z_i$ are the respective Pauli matrices, acting over the Qubit with index $i$.\n",
    "The submitted solution to this challenge consists of a quantum program written with Classiq that includes:\n",
    "\n",
    "\t1) A correct cost function and quantum ansatz\n",
    "\t2) A single execution of the quantum algorithm, using the state-vector simulator\n",
    "\t3) The quantum program’s CX-gate count\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Requirements:\n",
    "\n",
    "1) Install ***Python 3.12*** (NOTE - The Classiq SDK is currently supported for Python versions 3.8 to 3.12).\n",
    "2) Install  ***Jupyter*** (Optional for SDK, required to run this notebook)\n",
    "3) User registration at platform. **Note**: To use Classiq platform for free for non-commercial purposes, you must register. Then you can optionally install the Python SDK package and authenticate your account. [Click here for more derail...](https://docs.classiq.io/latest/classiq_101/registration_installations/)\n",
    "4) Install  ***Classiq 0.57*** (Classiq's Python SDK for quantum computing)  [https://platform.classiq.io/](https://platform.classiq.io/)\n",
    "5) Once above four steps completed \"Authenticate the device with your Classiq account\" as mentioned in step 3 link."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution Development"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Disclaimer**: For developing solution we have used \"[Variational Quantum Linear Solver (VQLS) with Linear Combination of Unitaries (LCU) Block Encoding.](https://docs.classiq.io/latest/explore/algorithms/vqls/lcu_vqls/vqls_with_lcu/)\" Ref[4]. Here it is solution for 3 qubit. We developped solution for 10 qubits. Some portion we copied as it is from Ref[4]. We worked on \"LCU Block Encoding\" and Ansats as for 10 qubit solutions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "The Variational Quantum Linear Solver (VQLS) is a quantum algorithm that harnesses the power of Variational Quantum Eigensolvers (VQE) to efficiently solve systems of linear equations:\n",
    "\n",
    "* **Input:** A matrix $\\textbf{A}$ and a known vector $|\\textbf{b}\\rangle$.\n",
    "\n",
    "* **Output:** An approximation of a normalized solution  $|x\\rangle$ proportional to $|\\textbf{x}\\rangle$, satisfying the equation $\\textbf{A} |\\textbf{x}\\rangle = |\\textbf{b}\\rangle$.\n",
    "\n",
    "***\n",
    "\n",
    "\n",
    "While the output of VQLS mirrors that of the HHL Quantum Linear-Solving Algorithm, VQLS distinguishes itself by its ability to operate on Noisy Intermediate-Scale Quantum (NISQ) computers. In contrast, HHL necessitates more robust quantum hardware and a larger qubit count, despite offering a faster computation speedup."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial we will cover an implementation example of a **Variational Quantum Linear Solver** [[1](#VQLS)] using block encoding , in particular, we will use linear combinations of unitaries, or LCUs for short, for the block encoding **for 10 qubits**\n",
    "\n",
    "As all variational algorithms, the VQLS is a hybrid algorithm in which we apply a classical optimization on the results of a parametrized (ansatz) quantum program"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quantum Part: Variational Circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To block encode a Variational Quantum Linear Solver as explained above we can define a high-level `block_encoding_vqls` function as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import numpy as np\n",
    "from classiq import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qfunc\n",
    "def block_encoding_vqls(\n",
    "    ansatz: QCallable,\n",
    "    block_encoding: QCallable,\n",
    "    prepare_b_state: QCallable,\n",
    ") -> None:\n",
    "    ansatz()\n",
    "    block_encoding()\n",
    "    invert(lambda: prepare_b_state())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From here, all we need to do is to define our `ansatz`, `block_encoding` and `prepare_b_state` to fit the above specific example and we are ready to build our model, synthesize it, execute it and analyze the results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classical Optimizer: Finding Optimal Parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "In order to variationally solve our linear problem, we define the\n",
    "cost function $C = 1- |\\langle b | \\Psi \\rangle|^2$ that we are going to\n",
    "minimize. \n",
    "\n",
    "At high level, the above could be implemented as follows:\n",
    "\n",
    "We construct a quantum model as depicted in the figure below. When measuring the above circuit in the computational basis, the probability of\n",
    "finding the system qubits it in the ground state (given the ancillary qubits measured\n",
    "in their ground state), is\n",
    "    $|\\langle 0 | U_b^\\dagger |\\Psi \\rangle|^2 = |\\langle b | \\Psi \\rangle|^2$\n",
    "\n",
    "We define a classical function that gets the quantum program, minimizes the cost function using the COBYLA optimizer, and returns the optimal parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.optimize import minimize\n",
    "\n",
    "from classiq.execution import ExecutionSession\n",
    "\n",
    "\n",
    "class VqlsOptimizer:\n",
    "    def __init__(self, qprog, ansatz_param_count, ansatz_var_name, aux_var_name):\n",
    "        self.qprog = qprog\n",
    "        self.ansatz_param_count = ansatz_param_count\n",
    "        self.ansatz_var_name = ansatz_var_name\n",
    "        self.aux_var_name = aux_var_name\n",
    "        self.es = ExecutionSession(qprog)\n",
    "        self.intermediate = {}\n",
    "\n",
    "    def get_cond_prop(self, res):\n",
    "        aux_prob_0 = 0\n",
    "        all_prob_0 = 0\n",
    "        for s in res:\n",
    "            if s.state[self.aux_var_name] == 0:\n",
    "                aux_prob_0 += s.shots\n",
    "                if s.state[self.ansatz_var_name] == 0:\n",
    "                    all_prob_0 = s.shots\n",
    "        return all_prob_0 / aux_prob_0\n",
    "\n",
    "    def my_cost(self, params):\n",
    "        results = self.es.sample(params)\n",
    "        return 1 - self.get_cond_prop(\n",
    "            results.parsed_counts_of_outputs([self.ansatz_var_name, self.aux_var_name])\n",
    "        )\n",
    "\n",
    "    def f(self, x):\n",
    "        cost = self.my_cost(\n",
    "            {\"params_\" + str(k): x[k] for k in range(self.ansatz_param_count)}\n",
    "        )\n",
    "        self.intermediate[tuple(x)] = cost\n",
    "        return cost\n",
    "\n",
    "    def optimize(self):\n",
    "        random.seed(1000)\n",
    "        out = minimize(\n",
    "            self.f,\n",
    "            x0=[\n",
    "                float(random.randint(0, 3000)) / 1000\n",
    "                for i in range(0, self.ansatz_param_count)\n",
    "            ],\n",
    "            method=\"COBYLA\",\n",
    "            options={\"maxiter\": 2000},\n",
    "        )\n",
    "        print(out)\n",
    "        out_f = [out[\"x\"][0 : self.ansatz_param_count]]\n",
    "        print(out_f)\n",
    "        plt.plot(\n",
    "            [l for l in range(len(self.intermediate))], list(self.intermediate.values())\n",
    "        )\n",
    "\n",
    "        return {\n",
    "            \"params_\" + str(k): list(self.intermediate.keys())[-1][k]\n",
    "            for k in range(self.ansatz_param_count)\n",
    "        }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "***\n",
    "Once the optimal variational weights `w` are found, we\n",
    "can generate the quantum state $|x\\rangle$. By measuring $|x\\rangle$ in\n",
    "the computational basis we can estimate the probability of each basis\n",
    "state.\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LCU Block Encoding: Block encoding the matrix A with LCU\n",
    "\n",
    "We treat a specific example based on a system of 10 qubits:\n",
    "\n",
    "$$A = \\sum_{i=1}^{10} X_i  + 0.1\\sum_{i=1}^{9} Z_i Z_{i+1} +I,$$\n",
    "\n",
    "\n",
    "where $Z_i, X_i, H_i$ represent the Pauli $Z$, Pauli $X$ and Hadamard gates applied to the qubit with index $i$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our first goal is to encode the Matrix A on a quantum circuit.  \n",
    "\n",
    "Using *linear combinations of unitaries* (LCU) we can encode the operator A\n",
    "\n",
    "$A$, representable as a linear combination of $L$ unitary matrices $A_0, A_1, \\dots, A_{L-1}$ we can implement a quantum circuit that applies the associated operator.\n",
    "\n",
    "$$A = \\sum_{i=1}^{10} X_i  + 0.1\\sum_{i=1}^{9} Z_i Z_{i+1} +I,$$\n",
    "\n",
    "where $c_l$ are arbitrary complex numbers. Crucially, we assume that each unitary $A_l$ can be efficiently implemented using a quantum circuit acting on $n$ qubits.\n",
    "\n",
    "First we will need to define some unitary operations associated to the simple example presented above.\n",
    "\n",
    "Let's apply the previous theory on our simple example based on a system of 10 qubits:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "paulis = []\n",
    "num_qubits=10\n",
    "# X terms\n",
    "for i in range(num_qubits):\n",
    "    pauli_str = ['I'] * num_qubits\n",
    "    pauli_str[i] = 'X'\n",
    "    paulis.append((''.join(pauli_str),1.0))\n",
    "    \n",
    "# ZZ terms\n",
    "for j in range(num_qubits - 1):\n",
    "    pauli_str = ['I'] * num_qubits\n",
    "    pauli_str[j] = 'Z'\n",
    "    pauli_str[j+1] = 'Z'\n",
    "    paulis.append((''.join(pauli_str),0.1))\n",
    "\n",
    "# I term\n",
    "for k in range(10):\n",
    "    pauli_str = ['I'] * num_qubits\n",
    "    paulis.append((''.join(pauli_str),1.0))\n",
    "# additional pading with zero\n",
    "for k in range(3):\n",
    "    pauli_str = ['I'] * num_qubits\n",
    "    paulis.append((''.join(pauli_str),0.0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_system_qubits = 10\n",
    "num_ancila_qubits = 5\n",
    "ansatz_param_count = 28\n",
    "\n",
    "\n",
    "error_bound = 0.0\n",
    "error_metric = \"LOSS_OF_FIDELITY\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To block encode the A we need only 3 thing:\n",
    "1. Representing it as a linear combination of $L$ unitary matrices (in our case we will use Pauli matrices)]\n",
    "2. A a unitary circuit $U_c$ that embeds the square root of $c$ (linear combination coefficients) into the quantum state\n",
    "3. A circuit that encodes $CA_l$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Preparing $U_c$  \n",
    "To construct $\\vec{c}$ from the above example we will we want to apply our Pauli's strings decomposition. For this we need  additional functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import cast\n",
    "\n",
    "from classiq import Pauli, PauliTerm\n",
    "\n",
    "my_list = {\"I\": Pauli.I, \"X\": Pauli.X, \"Y\": Pauli.Y, \"Z\": Pauli.Z}\n",
    "\n",
    "\n",
    "def pauli_str_to_enums(pauli):\n",
    "    return [my_list[s] for s in pauli]\n",
    "\n",
    "\n",
    "def pauli_operator_to_hamiltonian(pauli_list):\n",
    "    return [\n",
    "        PauliTerm(\n",
    "            pauli=pauli_str_to_enums(pauli), coefficient=cast(complex, coeff).real\n",
    "        )\n",
    "        for pauli, coeff in pauli_list\n",
    "    ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can construct $\\vec{c}$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "pauli_terms_structs = pauli_operator_to_hamiltonian(paulis)\n",
    "c = []\n",
    "for pauli_struct in pauli_terms_structs:\n",
    "    c.append(pauli_struct.coefficient)\n",
    "c = c / np.sum(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To prepare $U_c$ we need to embed the square root of the probability distribution `c`\n",
    "into the amplitudes of the ancillary state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qfunc\n",
    "def prepare_c(ancillary_qubits: QArray[QBit]):\n",
    "    inplace_prepare_state(list(c), error_bound, ancillary_qubits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### LCU sequence of all controlled-unitaries $CA_l$\n",
    "\n",
    "Next, we are left to define the LCU sequence of all controlled-unitaries $CA_l$,\n",
    "acting as $A_l$ on the system whenever the ancillary state is\n",
    "$|l\\rangle$. \n",
    "The `prepare_ca` function iterates over a list of Pauli terms $A_l$ and will apply $CA_l$ on the 10 qubit state `phi` controlled by the ancillary state $\\vec{c}$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qfunc\n",
    "def apply_pauli(pauli_value: CInt, qubit: QBit):\n",
    "    switch(\n",
    "        pauli_value,\n",
    "        [lambda: IDENTITY(qubit), lambda: X(qubit), lambda: Y(qubit), lambda: Z(qubit)],\n",
    "    )\n",
    "\n",
    "\n",
    "@qfunc\n",
    "def apply_pauli_term(pauli_term: PauliTerm, x: QArray[QBit]):\n",
    "    repeat(\n",
    "        count=x.len,\n",
    "        iteration=lambda index: apply_pauli(pauli_term.pauli[index], x[index]),\n",
    "    )\n",
    "\n",
    "\n",
    "@qfunc\n",
    "def apply_controlled_pauli_term(pauli_term: PauliTerm, x: QArray[QBit]):\n",
    "    repeat(\n",
    "        count=x.len,\n",
    "        iteration=lambda index: apply_pauli(pauli_term.pauli[index], x[index]),\n",
    "    )\n",
    "\n",
    "\n",
    "@qfunc\n",
    "def prepare_ca(\n",
    "    pauli_terms_list: CArray[PauliTerm],\n",
    "    system_qubits: QArray[QBit],\n",
    "    ancillary_qubits: QNum,\n",
    "):\n",
    "    repeat(\n",
    "        count=pauli_terms_list.len,\n",
    "        iteration=lambda i: control(\n",
    "            ancillary_qubits == i,\n",
    "            lambda: apply_pauli_term(pauli_terms_list[i], system_qubits),\n",
    "        ),\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preparing Ansatz\n",
    "\n",
    "Let's consider our ansatz $V(w)$, such that : \n",
    "\n",
    "$$|x\\rangle = V(w) |0\\rangle $$\n",
    "\n",
    "\n",
    "This allows us to \"search\" the state space by varying some set of parameters, $w$. \n",
    "\n",
    "The ansatz that we will use for this 10 qubits system implementation takes in 28 parameters as defined in `apply_fixed_10_qubit_system_ansatz` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qfunc\n",
    "def apply_ry_on_all(params: CArray[CReal], io: QArray[QBit]):\n",
    "    repeat(count=io.len, iteration=lambda index: RY(params[index], io[index]))\n",
    "\n",
    "\n",
    "@qfunc\n",
    "def apply_fixed_10_qubit_system_ansatz(\n",
    "    angles: CArray[CReal], system_qubits: QArray[QBit]\n",
    "):\n",
    "    apply_ry_on_all(angles[0:num_system_qubits], system_qubits)\n",
    "    base_ang=num_system_qubits\n",
    "    for i in range(num_system_qubits-1):        \n",
    "        if ((i % 2) != 0):    \n",
    "            CZ(system_qubits[i], system_qubits[i+1])            \n",
    "            RY(angles[base_ang], system_qubits[i])            \n",
    "            base_ang+=1           \n",
    "            RY(angles[base_ang], system_qubits[i+1])            \n",
    "            base_ang+=1\n",
    "            \n",
    "    for i in range(num_system_qubits-1):        \n",
    "        if ((i % 2) == 0):\n",
    "            CZ(system_qubits[i], system_qubits[i+1])\n",
    "    \n",
    "    base_ang_e=base_ang+num_system_qubits\n",
    "\n",
    "    apply_ry_on_all(angles[base_ang:base_ang_e], system_qubits)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a fixed hardware ansatz: the configuration of quantum gates remains the same for each run of the circuit, all that changes are the parameters. The applications of $Ry$ gates allow us to search the state space, while the $CZ$ gates create \"interference\" between the different qubit states."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE:** We have tried some differernt Ansatz. For example using only $Ry$ gates i.e. not used the $CZ$ layer. 10 $Ry$ on 10 qubits.  ***apply_ry_on_all(angles, system_qubits)***.  Assign correct paramters value to , i.e. *ansatz_param_count = 10*. This solution with this ansatz takes lesser time to complete execution. We have prepared different notebook for this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### Running the VQLS\n",
    "\n",
    "Now, we can define the main function: we call `block_encoding_vqls` with the arguments of our specific example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "@qfunc\n",
    "def main(\n",
    "    params: CArray[CReal, ansatz_param_count],\n",
    "    ancillary_qubits: Output[QNum],\n",
    "    system_qubits: Output[QNum],\n",
    "):\n",
    "\n",
    "    allocate(num_ancila_qubits, ancillary_qubits)\n",
    "    allocate(num_system_qubits, system_qubits)\n",
    "\n",
    "    block_encoding_vqls(\n",
    "        ansatz=lambda: apply_fixed_10_qubit_system_ansatz(params, system_qubits),\n",
    "        block_encoding=lambda: within_apply(\n",
    "            within=lambda: prepare_c(ancillary_qubits),\n",
    "            apply=lambda: prepare_ca(\n",
    "                pauli_terms_structs, system_qubits, ancillary_qubits\n",
    "            ),\n",
    "        ),\n",
    "        prepare_b_state=lambda: apply_to_all(H, system_qubits),\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Constructing the model, synthesizing and executing on Classiq's simulator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Opening: https://platform.classiq.io/circuit/0f9ac94b-89c9-49ec-a1c5-668c11e07457?version=0.57.0\n"
     ]
    }
   ],
   "source": [
    "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n",
    "from classiq.synthesis import set_execution_preferences\n",
    "\n",
    "backend_preferences = ClassiqBackendPreferences(backend_name=\"simulator_statevector\")\n",
    "model = create_model(main)\n",
    "\n",
    "model = set_execution_preferences(\n",
    "    model,\n",
    "    execution_preferences=ExecutionPreferences(\n",
    "        num_shots=2048, job_name=\"vqls_with_lcu_10Qbit\", backend_preferences=backend_preferences\n",
    "    ),\n",
    ")\n",
    "qprog = synthesize(model)\n",
    "show(qprog)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from classiq import write_qmod\n",
    "\n",
    "write_qmod(model, name=\"vqls_with_lcu_10Qbit\", decimal_precision=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We run the classical optimizer to get the optimal parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " message: Optimization terminated successfully.\n",
      " success: True\n",
      "  status: 1\n",
      "     fun: 0.04019823788546251\n",
      "       x: [ 7.669e-01  3.175e+00 ...  1.704e+00  5.242e-02]\n",
      "    nfev: 352\n",
      "   maxcv: 0.0\n",
      "[array([0.7669234 , 3.1752262 , 0.54619642, 3.01106404, 0.81217   ,\n",
      "       1.04621954, 3.03704237, 3.125401  , 2.00862933, 1.54680304,\n",
      "       0.06192385, 1.24050983, 3.80091389, 1.39688818, 1.19229511,\n",
      "       3.76053945, 2.66577454, 2.02577354, 2.18012252, 4.57966647,\n",
      "       1.0331208 , 1.10921541, 0.89111932, 1.62661007, 1.0481476 ,\n",
      "       1.9410607 , 1.70425857, 0.05241772])]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "optimizer = VqlsOptimizer(\n",
    "    qprog, ansatz_param_count, \"system_qubits\", \"ancillary_qubits\"\n",
    ")\n",
    "optimal_params = optimizer.optimize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Time Taken to complete: Start time: 10:10  End time: 17:20 ---- Total time taken 7 Hours 10 minutes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CX-gate count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of CX Gates: 3586\n"
     ]
    }
   ],
   "source": [
    "circuit = QuantumProgram.from_qprog(qprog)\n",
    "cx_counts=circuit.transpiled_circuit.count_ops[\"cx\"]\n",
    "print(f\"Number of CX Gates: {cx_counts}\")\n",
    "\n",
    "#circuit.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measuring the Quantum Solution\n",
    "\n",
    "Finally, we can apply the optimal params to measure the quantum results for $\\vec{x}$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qfunc\n",
    "def main(io: Output[QArray[QBit]]):\n",
    "    allocate(num_system_qubits, io)\n",
    "    apply_fixed_10_qubit_system_ansatz(list(optimal_params.values()), io)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n",
    "from classiq.synthesis import set_execution_preferences\n",
    "\n",
    "backend_preferences = ClassiqBackendPreferences(backend_name=\"simulator_statevector\")\n",
    "qmod = create_model(main)\n",
    "\n",
    "qmod = set_execution_preferences(\n",
    "    qmod,\n",
    "    execution_preferences=ExecutionPreferences(\n",
    "        num_shots=2048, job_name=\"vqls_with_lcu_10Qbit\", backend_preferences=backend_preferences\n",
    "    ),\n",
    ")\n",
    "\n",
    "\n",
    "qprog = synthesize(qmod)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "job = execute(qprog)\n",
    "results = job.result()[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "state_vector = results.value.state_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.00047749715666810824,\n",
       " 0.0003231724403471997,\n",
       " 0.0003714677530577092,\n",
       " 0.00029670558309079806,\n",
       " 0.0013053690730441352,\n",
       " 0.0008243329901252833,\n",
       " 0.0010294120863271756,\n",
       " 0.0008893617195799956,\n",
       " 0.0013972644768662976,\n",
       " 0.0009187198100933298,\n",
       " 0.0010932596230165325,\n",
       " 0.0009030589241086983,\n",
       " 0.0007017309493726455,\n",
       " 0.00045445109365615437,\n",
       " 0.000550689237786297,\n",
       " 0.0004627431160155046,\n",
       " 0.0007607260914856596,\n",
       " 0.0005114921891756966,\n",
       " 0.0005925828047028221,\n",
       " 0.0004769963087704867]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "probabilities = []\n",
    "for key, val in state_vector.items():\n",
    "    probabilities.append(abs(complex(val)) ** 2)\n",
    "\n",
    "\n",
    "probabilities[0:20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.021851708323792633,\n",
       " 0.017976997534271393,\n",
       " 0.019273498723836033,\n",
       " 0.01722514392075718,\n",
       " 0.03612989168326049,\n",
       " 0.028711199733297166,\n",
       " 0.03208445240809286,\n",
       " 0.029822168257522718,\n",
       " 0.03738000102817411,\n",
       " 0.03031039112405727,\n",
       " 0.03306447675401098,\n",
       " 0.030050938822417817,\n",
       " 0.026490204781629105,\n",
       " 0.02131785856168847,\n",
       " 0.023466768797307757,\n",
       " 0.02151146475755439,\n",
       " 0.02758126341351425,\n",
       " 0.02261619307433717,\n",
       " 0.024343023737876567,\n",
       " 0.02184024516278347]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "amplitudes = []\n",
    "for key, val in state_vector.items():\n",
    "    amplitudes.append(abs(complex(val)))\n",
    "\n",
    "\n",
    "amplitudes[0:20]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## References\n",
    "\n",
    "<a name='VQLS'>[1]</a>: [Bravo-Prieto et al.,Variational Quantum Linear Solver. (2020)](https://arxiv.org/pdf/1909.05820.pdf)\n",
    "\n",
    "[2]:\tThe Hamiltonian Simulation Guides using Classiq\n",
    "\n",
    "[3]:\tThe Quantum Machine Learning Guide using Classiq\n",
    "\n",
    "<a name='VQLS-with-LCU'>[4]</a>: [Variational Quantum Linear Solver (VQLS) with Linear Combination of Unitaries (LCU) Block Encoding.](https://docs.classiq.io/latest/explore/algorithms/vqls/lcu_vqls/vqls_with_lcu/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Classiq resources:\n",
    "\n",
    "1.\t[Getting Started with Classiq - Classiq 101](https://docs.classiq.io/latest/classiq_101/)\n",
    "  \n",
    "3.\t[Classiq’s documentation](https://docs.classiq.io/latest/)\n",
    "  \n",
    "5.\t[Classiq Library](https://docs.classiq.io/latest/explore/) of many implementation algorithms and applications\n",
    "\n",
    "7.\t[Classiq Community Slack](https://short.classiq.io/join-slack) is available for any questions you might have"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Backend name: Default\n",
    "Depth: 5806\n",
    "Width: 18\n",
    "Gate count\n",
    "\n",
    "CX : 3586\n",
    "U1 : 2313\n",
    "U : 490\n",
    "P : 319\n",
    "TDG : 278\n",
    "T : 278\n",
    "X : 79\n",
    "RY : 36\n",
    "H : 33\n",
    "CZ : 27\n",
    "Hardware details\n",
    "\n",
    "Basis Gates: id, r, sdg, rx, x, y, t, sxdg, u1, cz, cx, ry, s, rz, tdg, p, sx, cy, u2, z, h, u\n",
    "Connectivity Map:\n",
    "undefined\n",
    "Symmetric Connectivity: True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.7"
  },
  "vscode": {
   "interpreter": {
    "hash": "a92532c879895fdbdcd7b9af93b00a95f00d91e2c0b5de957658bacdd1492da5"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}