Review_EDO_QC/Quantum Circuits & Ordinary Differentiable Equations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cdb45a49",
   "metadata": {},
   "source": [
    "*Summary by: Dr. Carolina Perdomo for QuantumQuipu.*\n",
    "\n",
    "We are living in an exciting era marked by the advent of quantum computing, a technological leap that holds the potential to revolutionize problem-solving by using the power of quantum mechanics. These quantum devices, often referred to as *Noisy Intermediate-Scale Quantum (NISQ) computers*, while imperfect in terms of size, noise, and error rates, represent the culmination of years of global scientific effort. In this notebook, we will focus not on their limitations but on what they can accomplish. We'll explore how NISQ devices, in combination sometimes with classical computers, can address a critical challenge in science and industry: **solving differential equations**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec93ec98",
   "metadata": {},
   "source": [
    "## Why this? Main Points:\n",
    "\n",
    "Significance of Differential Equations:\n",
    "\n",
    "- Differential equations play a pivotal role in understanding and modeling various physical processes, including heat transfer, fluid dynamics, and chemical reactions. For example, in quantum industrial applications, the solution to differential equations is crucial for optimizing molecular structures in quantum chemistry simulations and for reducing CO2 emissions by converting CO2 into valuable chemicals.\n",
    "\n",
    "- Challenges in Solving Differential Equations: The complexity of many differential equations often necessitates numerical solutions. Classical computing resources may fall short in handling intricate problems, such as aerospace modeling or simulating catalytic reactions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccab0198",
   "metadata": {},
   "source": [
    "# Algorithms\n",
    "\n",
    "## (1) Linear Differential Equations.\n",
    "\n",
    "- References: [A Quantum Algorithm for Solving Linear Differential Equations: Theory and Experiment](https://arxiv.org/pdf/1807.04553.pdf) and [QIC710-Final-Presentation](https://github.com/andrijapau/QIC710-Final-Presentation).\n",
    "- Interesting lectures: [Quantum algorithm for solving linear equations](https://www.youtube.com/watch?v=KtIPAPyaPOg)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62dc2fc5",
   "metadata": {},
   "source": [
    "We will find the solution of the next linear differential equation:\n",
    "\n",
    "$\\dfrac{dp}{dt}=Mp_{0}+b$,\n",
    "\n",
    "where **$p(t)$** is a vector, M a matrix $NxN$, **$p_{0}$** the initial state, and **b** is a vector.\n",
    "\n",
    "We will follow ther references mentioned before. For our implementation case:\n",
    "\n",
    "$M=\\begin{bmatrix}\n",
    "0 & 1 \\\\\n",
    "1 & 0 \n",
    "\\end{bmatrix}$,\n",
    "\n",
    "$p_{0}=\\dfrac{1}{\\sqrt{2}}\\begin{bmatrix}\n",
    "1 \\\\\n",
    "1 \n",
    "\\end{bmatrix}$, and\n",
    "\n",
    "$b=\\dfrac{1}{\\sqrt{2}}\\begin{bmatrix}\n",
    "1 \\\\\n",
    "1 \n",
    "\\end{bmatrix}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "153fed3e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.70710678 0.70710678] [0.70710678 0.70710678] [[0 1]\n",
      " [1 0]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import scipy as sp\n",
    "\n",
    "# Define the space t over which we are going to solve the equation:\n",
    "t_d = np.linspace(0.01, 3.01, 25) # 25 points between 0.01 and 3.01 (including it). Note that these are points in the domain\n",
    "\n",
    "# Let's define the parameters:\n",
    "p0 = (1 / (np.sqrt(2))) * np.array([1, 1])\n",
    "b = (1 / (np.sqrt(2))) * np.array([1, 1])\n",
    "M = np.array([[0, 1], [1, 0]])\n",
    "\n",
    "print(p0,b,M)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa8b0003",
   "metadata": {},
   "source": [
    "To encode the N-dimensional vectors $p_{0}$ and $b$, we'll need to consider the given values:\n",
    "\n",
    "- N is the dimension of the vectors. In this case, N is 2 since the vectors $p_{0}$ and $b$ are 2-dimensional.\n",
    "\n",
    "- k is the approximation order in the Taylor series, we are working until the second order. Therefore, k is 2.\n",
    "\n",
    "- T is defined as T = 1 + k, so in this case, T = 1 + 2 = 3.\n",
    "\n",
    "Based on the information in the *Appendix A*, we need to encode $p_{0}$ and $b$ with the following: a (1 + T)-qubit ancilla register and a $log_{2}(N)$-qubit work system. As the vectors $p_{0}$ and $b$ are 2-dimensional, therefore, we need $log_{2}(2) = 1$ work qubit. We will need also 3 ancilla qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "dadf1f85",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Circuit parameters:\n",
    "anc_reg1, anc_reg2, work_qubits = 1, 2, 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "71723f27",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "from qiskit import Aer, IBMQ, QuantumCircuit, QuantumRegister, execute, transpile\n",
    "from qiskit.circuit.library.standard_gates import XGate\n",
    "from qiskit.quantum_info.operators import Operator\n",
    "\n",
    "\n",
    "class LDESolver:\n",
    "    '''\n",
    "    Took from https://github.com/andrijapau/QIC710-Final-Presentation\n",
    "    '''\n",
    "\n",
    "    def __init__(self, num_of_anc_reg1, num_of_anc_reg2, num_of_work_qubits, t):\n",
    "\n",
    "        self.shots = 10000\n",
    "\n",
    "        self.create_circuit(num_of_anc_reg1, num_of_anc_reg2, num_of_work_qubits)\n",
    "\n",
    "        # Creates the V and W unitaries (for more information check Appendix A of arXiv: 1807.04553v1 [quant-ph])\n",
    "        self.create_VS_WS(t)\n",
    "        self.create_V()\n",
    "\n",
    "        # Encoding Section\n",
    "        self.encode()\n",
    "\n",
    "        # Entanglement Section\n",
    "        self.entanglement()\n",
    "\n",
    "        # Decoding Section\n",
    "        self.decode()\n",
    "\n",
    "        self.measure()\n",
    "\n",
    "        self.execute()\n",
    "\n",
    "        self.display_results()\n",
    "        \n",
    "    def encode(self):\n",
    "        '''\n",
    "        Encoding part of the quantum circuit.\n",
    "        '''\n",
    "\n",
    "        # Create a seperate circuit to turn into VS1 gate.\n",
    "        S1_circuit = QuantumCircuit(3)\n",
    "\n",
    "        # Ux (to evolve the work qubits int0 |p(0)>):\n",
    "        S1_circuit.h(2)\n",
    "\n",
    "        # Vs1 (equation 12- operations acting on the second ancilla register):\n",
    "        S1_circuit.unitary(self.v_S1_U, [0, 1], label='VS1')\n",
    "        S1_gate = S1_circuit.to_gate().control(1, ctrl_state='0')\n",
    "\n",
    "        # Create a seperate circuit to turn into VS1 gate:\n",
    "        S2_circuit = QuantumCircuit(3)\n",
    "\n",
    "        # Ub (to evolve the work qubits into |b>):\n",
    "        S2_circuit.h(2)\n",
    "\n",
    "        # Vs2 (equation 13- operations acting on the second ancilla register):\n",
    "        S2_circuit.unitary(self.v_S2_U, [0, 1], label='VS2')\n",
    "        S2_gate = S2_circuit.to_gate().control(1, ctrl_state='1')\n",
    "\n",
    "        # Attach encoding part of circuit:\n",
    "        self.circuit.unitary(self.V_U, 0, label='V')\n",
    "        self.circuit.append(S1_gate, [0, 1, 2, 3])\n",
    "        self.circuit.append(S2_gate, [0, 1, 2, 3])\n",
    "\n",
    "    def entanglement(self):\n",
    "        '''\n",
    "        Calculates the entanglement operator for a given order.\n",
    "        '''\n",
    "\n",
    "        order = 3\n",
    "        num_of_ancilla = int(np.log2(order + 1)) # Check Appendix A.\n",
    "        for i in range(2 ** num_of_ancilla):\n",
    "            if i % 2 != 0:\n",
    "                ctrl = \"\".join(bin(i)[2:][::-1].ljust(num_of_ancilla, '0'))\n",
    "                self.circuit.append(\n",
    "                    XGate().control(num_ctrl_qubits=num_of_ancilla, ctrl_state=ctrl),\n",
    "                    [self.anc_reg2[0], self.anc_reg2[1], self.work_qubit_reg[-1]]\n",
    "                )\n",
    "\n",
    "    def decode(self):\n",
    "        '''\n",
    "        Decoding part of the quantum circuit.\n",
    "        '''\n",
    "\n",
    "        # WS1\n",
    "        S1_circuit = QuantumCircuit(3)\n",
    "        S1_circuit.unitary(self.w_S1_U, [0, 1], label='WS1')\n",
    "        S1_gate = S1_circuit.to_gate().control(1, ctrl_state='0')\n",
    "\n",
    "        # WS2\n",
    "        S2_circuit = QuantumCircuit(3)\n",
    "        S2_circuit.unitary(self.w_S2_U, [0, 1], label='WS2')\n",
    "        S2_gate = S2_circuit.to_gate().control(1, ctrl_state='1')\n",
    "\n",
    "        # Append decoding part onto circuit.\n",
    "        self.circuit.append(S1_gate, [0, 1, 2, 3])\n",
    "        self.circuit.append(S2_gate, [0, 1, 2, 3])\n",
    "        self.circuit.unitary(self.W_U, 0, label='W')\n",
    "\n",
    "    def create_V(self):\n",
    "        '''\n",
    "        Creates the V and W operators\n",
    "        '''\n",
    "\n",
    "        self.N = np.sqrt(self.C ** 2 + self.D ** 2)\n",
    "        V = (1 / self.N) * np.array([[self.C, self.D], [self.D, -self.C]]) # Normalization factors, equation 10.\n",
    "\n",
    "        self.V_U = Operator(V)\n",
    "        self.W_U = self.V_U.transpose()\n",
    "\n",
    "    def create_VS_WS(self, t):\n",
    "        '''\n",
    "        Creates the V and W matrices using Gram-Schmidt method.\n",
    "        '''\n",
    "\n",
    "        v_S1 = np.array(\n",
    "            [[np.sqrt(self.e(t, 0)),\n",
    "              np.sqrt(self.e(t, 1)),\n",
    "              np.sqrt(self.e(t, 2)),\n",
    "              np.sqrt(self.e(t, 3))]]\n",
    "        )\n",
    "\n",
    "        v_S2 = np.array(\n",
    "            [[np.sqrt(self.e(t, 1)),\n",
    "              np.sqrt(self.e(t, 2)),\n",
    "              np.sqrt(self.e(t, 3)),\n",
    "              0]]\n",
    "        )\n",
    "\n",
    "        self.C = np.sqrt(np.sum(v_S1 ** 2, axis=1)[0])\n",
    "        self.D = np.sqrt(np.sum(v_S2 ** 2, axis=1)[0])\n",
    "\n",
    "        v_S1 = (1 / self.C) * v_S1\n",
    "        v_S2 = (1 / self.D) * v_S2\n",
    "\n",
    "        self.v_S1_U = Operator(self.create_unitary(v_S1))\n",
    "        self.v_S2_U = Operator(self.create_unitary(v_S2))\n",
    "\n",
    "        self.w_S1_U, self.w_S2_U = self.v_S1_U.transpose(), self.v_S2_U.transpose()\n",
    "\n",
    "    def e(self, t, index):\n",
    "        '''\n",
    "        Term in the Taylor Expansion of exp(x) used in W and V matrices.\n",
    "        '''\n",
    "        return (t ** index) / (math.factorial(index))\n",
    "\n",
    "    def create_unitary(self, v):\n",
    "        '''\n",
    "        Function that calculates the unitary matrix for a given vector in the first column. From:\n",
    "        https://math.stackexchange.com/questions/4160055/create-a-unitary-matrix-out-of-a-column-vector\n",
    "        '''\n",
    "\n",
    "        dim = v.size\n",
    "        # Return identity if v is a multiple of e1\n",
    "        if v[0][0] and not np.any(v[0][1:]):\n",
    "            return np.identity(dim)\n",
    "        e1 = np.zeros(dim)\n",
    "        e1[0] = 1\n",
    "        w = v / np.linalg.norm(v) - e1\n",
    "        return np.identity(dim) - 2 * ((np.dot(w.T, w)) / (np.dot(w, w.T)))\n",
    "\n",
    "    def execute(self):\n",
    "        '''\n",
    "        Executes the created quantum circuit on the IBMQ Qasm Simulator\n",
    "        '''\n",
    "        self.num_of_qubits = self.circuit.num_qubits\n",
    "\n",
    "        self.backend = Aer.get_backend('qasm_simulator')\n",
    "        job = execute(\n",
    "            transpile(self.circuit, backend=self.backend),\n",
    "            backend=self.backend,\n",
    "            shots=self.shots\n",
    "        )\n",
    "\n",
    "        self.result = job.result()\n",
    "\n",
    "    def display_results(self): # Measurement counts are obtained.\n",
    "        '''\n",
    "        Computes results as a class variable to be processed in main.\n",
    "        '''\n",
    "\n",
    "        counts = self.result.get_counts()\n",
    "        probs = {string: count / self.shots for string, count in counts.items()}\n",
    "\n",
    "        y_adj, x_adj = 0, 0 # To adjust the probability values.\n",
    "        if '0001' in probs.keys():\n",
    "            y_adj = probs['0001']\n",
    "        if '1001' in probs.keys():\n",
    "            x_adj = probs['1001']\n",
    "\n",
    "        self.y = (self.N ** 2) * np.sqrt(probs['1000'] + y_adj)\n",
    "        self.x = (self.N ** 2) * np.sqrt(probs['0000'] + x_adj)\n",
    "\n",
    "    def measure(self):\n",
    "        '''\n",
    "        Measures the quantum circuit over all qubits.\n",
    "        '''\n",
    "\n",
    "        self.circuit.measure_all()\n",
    "\n",
    "    def create_circuit(self, num_of_anc_reg1, num_of_anc_reg2, num_of_work_qubits):\n",
    "        '''\n",
    "        Define and set-up quantum circuit.\n",
    "        '''\n",
    "\n",
    "        self.circuit = QuantumCircuit(name='LDE_Solver_Circuit')\n",
    "\n",
    "        self.anc_reg1 = QuantumRegister(num_of_anc_reg1, name='anc1')\n",
    "\n",
    "        self.anc_reg2 = QuantumRegister(num_of_anc_reg2, name='anc2')\n",
    "\n",
    "        self.work_qubit_reg = QuantumRegister(num_of_work_qubits, name='work')\n",
    "\n",
    "        self.circuit.add_register(self.anc_reg1, self.anc_reg2, self.work_qubit_reg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c16a139f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def solve_p(t, M, p0, b):\n",
    "    '''\n",
    "    Finds the analytic solution for the matrix Linear Differential Equation (LDE): dp/dt = M * p0 + b.\n",
    "    '''\n",
    "    # Step 1: Calculate e^(M * t)\n",
    "    exp_Mt = sp.linalg.expm(M * t)\n",
    "\n",
    "    # Step 2: Calculate the difference between e^(M * t) and the identity matrix\n",
    "    diff_exp_Mt = exp_Mt - np.identity(2)\n",
    "\n",
    "    # Step 3: Calculate the inverse of matrix M\n",
    "    inv_M = np.linalg.inv(M)\n",
    "\n",
    "    # Step 4: Calculate the result by multiplying matrices\n",
    "    p = np.matmul(exp_Mt, p0) + np.matmul(diff_exp_Mt, np.matmul(inv_M, b))\n",
    "\n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0c0d63ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "\n",
    "    # Define arrays to store information:\n",
    "    x_C, y_C = [], []\n",
    "    x_Q, y_Q = [], []\n",
    "    \n",
    "    for t in t_d:\n",
    "        # Create circuit\n",
    "        circuit = LDESolver(anc_reg1, anc_reg2, work_qubits, t)\n",
    "\n",
    "        # Solve analytic expression\n",
    "        x_analytic, y_analytic = solve_p(t, M, p0, b)\n",
    "\n",
    "        # print(f\"Analytic x({round(t, 3)}) = {round(x_analytic, 3)}\")\n",
    "        # print(f\"Analytic y({round(t, 3)}) = {round(y_analytic, 3)}\")\n",
    "        #print(f\"Quantum x({round(t, 3)}) = {round(circuit.x, 3)}\")\n",
    "        #print(f\"Quantum y({round(t, 3)}) = {round(circuit.y, 3)}\")\n",
    "\n",
    "        # Store results\n",
    "        x_C.append(x_analytic)\n",
    "        y_C.append(y_analytic)\n",
    "        x_Q.append(circuit.x) # They are not returned directly from the class, they are calculated and stored. \n",
    "        y_Q.append(circuit.y) # They are not returned directly from the class, they are calculated and stored. \n",
    "\n",
    "    # Plot results\n",
    "    plt.plot(t_d, x_C, 'r--', label='x(t) Analytic')\n",
    "    plt.plot(t_d, x_Q, 'r', label='x(t) Quantum')\n",
    "\n",
    "    plt.plot(t_d, y_C, 'b--', label='y(t) Analytic')\n",
    "    plt.plot(t_d, y_Q, 'b', label='y(t) Quantum')\n",
    "\n",
    "    plt.xlabel(r\"$t$, time\")\n",
    "    plt.ylabel(r\"Position Components\")\n",
    "\n",
    "    plt.legend(loc='best')\n",
    "    plt.title(\"Position Components v.s. Time\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "    #plt.plot(x_C, y_C, 'k--', label='Analytic')\n",
    "    #plt.plot(x_Q, y_Q, 'r', label='Quantum')\n",
    "    #plt.legend(loc='best')\n",
    "    #plt.xlabel(r\"$x(t)$\")\n",
    "    #plt.ylabel(r\"$y(t)$\")\n",
    "    #plt.title(\"XY Phase Space\")\n",
    "\n",
    "    #plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd9b4ced",
   "metadata": {},
   "source": [
    "The vector p typically represents a state in a multi-dimensional space, and \"x\" and \"y\" components represent two specific dimensions or components of the state. So, when we solve this matrix LDE, we are actually solving for the time evolution of both the \"x\" and \"y\" components of the state \"p\" over time \"t.\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "639f867e",
   "metadata": {},
   "source": [
    "## (2) Systems of (linear) coupled equations - HLL"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86354ff3",
   "metadata": {},
   "source": [
    "- Reference: [hhl_experiment](https://github.com/quantastica/hhl_experiment/tree/master).\n",
    "- Interesting lectures: [El algoritmo HHL](https://www.youtube.com/watch?v=vBHTKxahLhk&list=PLhYoqmIacCv8qQNpNMZBruq18ciFbBUEA), and [HHL Algorithm: Solving Systems of Linear Equations](https://medium.com/mit-6-s089-intro-to-quantum-computing/hhl-algorithm-solving-systems-of-linear-equations-e4d82d340951)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7342d04",
   "metadata": {},
   "source": [
    "The **HHL (Harrow-Hassidim-Lloyd)** algorithm is primarily designed for solving systems of linear equations, particularly those that arise in scientific and engineering applications. It is a quantum algorithm for solving linear systems of equations of the form |A>x = |b>, where |A> is a Hermitian matrix (**VERY IMPORTANT**), |b> is a known vector, and x is the vector we want to know. We want to construct |x>.\n",
    "\n",
    "The algorithm can be used to construct the vector |x>. This can be applied to many problems, including solving a system of coupled linear equations. In a system of coupled linear equations, we have multiple linear equations with multiple variables that are interconnected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b693e0cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.algorithms.linear_solvers.hhl import HHL\n",
    "from qiskit.quantum_info import Statevector\n",
    "\n",
    "def is_symetric(a, rtol=1e-05, atol=1e-08): # To check is a is symmetric. rtol and atol are tolerance parameters.\n",
    "    return np.allclose(a, a.T, rtol=rtol, atol=atol) # Compare it to the transpose with np.allclose.\n",
    "\n",
    "\n",
    "def linalg_qsolve(A, b, verbose=False, print_qasm=False): # Remember Ax=b.\n",
    "    matrix = A.copy()\n",
    "    vector = b.copy()\n",
    "    \n",
    "    # Rescale problem to log2.\n",
    "    if(np.log2(len(matrix)) < np.ceil(np.log2(len(matrix)))):\n",
    "        while np.log2(len(matrix)) < np.ceil(np.log2(len(matrix))):\n",
    "            matrix = np.vstack([matrix, np.zeros(len(matrix))])\n",
    "            matrix = np.c_[ matrix, np.append(np.zeros(len(matrix) - 1), -1) ]\n",
    "\n",
    "        while np.log2(len(vector)) < np.ceil(np.log2(len(vector))):\n",
    "            vector = np.append(vector, [0])\n",
    "\n",
    "    # Check if input is hermitian. # VERY IMPORTANT FOR HHL.\n",
    "    if(not is_symetric(matrix)):\n",
    "        # Convert A to hermitian in worst case scenario.\n",
    "        Z = np.zeros((len(matrix), len(matrix)))\n",
    "        matrix = np.block([[Z, matrix], [matrix.T, Z]])\n",
    "\n",
    "        # Rescale b:\n",
    "        vector = np.append(np.zeros(len(vector)), vector)\n",
    "\n",
    "    hhl_solution = HHL().solve(matrix, vector) # We have HHL in qiskit, yay!\n",
    "    \n",
    "    state_vector = Statevector(hhl_solution.state).data\n",
    "    \n",
    "    num_qubits = hhl_solution.state.num_qubits\n",
    "    offset = 2**(num_qubits - 1)\n",
    "    x = [] # The solution is converted into a real-valued vector x.\n",
    "    for index in range(len(vector)):\n",
    "        x.append(state_vector[offset + index])\n",
    "\n",
    "    x = np.real(x)\n",
    "    \n",
    "    x = hhl_solution.euclidean_norm * (x / np.linalg.norm(x))\n",
    "\n",
    "    if(verbose): # This is extra to compare with the classical solution.\n",
    "        # Get classical solution (to compare with quantum solution)\n",
    "        xc = np.linalg.solve(A, b)\n",
    "        \n",
    "        print(\"Classical solution:\", xc)\n",
    "        print(\"Quantum solution:  \", x)\n",
    "\n",
    "        display(hhl_solution.state.draw(output=\"mpl\"))\n",
    "        transpiled = transpile(hhl_solution.state, basis_gates=['id', 'u3', 'cx'], optimization_level=3)\n",
    "        print(transpiled.count_ops())\n",
    "    \n",
    "    if(print_qasm): # Human-readable.\n",
    "        print(transpiled.qasm())\n",
    "        \n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6bde6a1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "*** Problem 1 ***\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\dafda\\AppData\\Local\\Temp\\ipykernel_25352\\3233648818.py:30: DeprecationWarning: The HHL class is deprecated as of Qiskit Terra 0.22.0 and will be removed\n",
      "        no sooner than 3 months after the release date.\n",
      "        It is replaced by the tutorial at https://qiskit.org/textbook/ch-applications/hhl_tutorial.html\"\n",
      "        \n",
      "  hhl_solution = HHL().solve(matrix, vector) # We have HHL in qiskit, yay!\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classical solution: [ 0.86023308 -1.48719142]\n",
      "Quantum solution:   [ 0.87786206 -1.46956242]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 676.834x451.5 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict([('u3', 119), ('cx', 90)])\n",
      "\n",
      "\n",
      "\n",
      "*** Problem 2 ***\n",
      "\n",
      "Classical solution: [-0.00686554 -0.60915108]\n",
      "Quantum solution:   [-0.01168517 -0.60433144]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 676.431x451.5 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict([('u3', 120), ('cx', 90)])\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "problems = [ \n",
    "    {\n",
    "        \"A\": np.array([\n",
    "            [0.86540304, 0.35951908],\n",
    "            [0.35951908, 0.86540304]\n",
    "        ]),\n",
    "\n",
    "        \"b\": np.array([ 0.20977463, -0.97774977])\n",
    "    },\n",
    "\n",
    "    {\n",
    "        \"A\": np.array([\n",
    "            [ 1.64120030,  -0.08631518 ],\n",
    "            [-0.08631518,   1.64120030 ]\n",
    "        ]),\n",
    "\n",
    "        \"b\": np.array([ 0.04131126, -0.99914633])\n",
    "    }\n",
    "]\n",
    "\n",
    "\n",
    "for problem_index in range(len(problems)):\n",
    "    print(\"\\n*** Problem\", str(problem_index + 1), \"***\\n\")\n",
    "\n",
    "    problem = problems[problem_index]\n",
    "\n",
    "    x = linalg_qsolve(problem[\"A\"], problem[\"b\"], verbose=True, print_qasm=False)\n",
    "\n",
    "    print(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce511209",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Just by fun, Qiskit example:\n",
    "from qiskit.algorithms.linear_solvers.matrices import TridiagonalToeplitz\n",
    "from qiskit.algorithms.linear_solvers.observables import MatrixFunctional\n",
    "\n",
    "matrix = TridiagonalToeplitz(2, 1, 1 / 3, trotter_steps=2)\n",
    "right_hand_side = [1.0, -2.1, 3.2, -4.3]\n",
    "observable = MatrixFunctional(1, 1 / 2)\n",
    "rhs = right_hand_side / np.linalg.norm(right_hand_side)\n",
    "\n",
    "# Initial state circuit\n",
    "num_qubits = matrix.num_state_qubits\n",
    "qc = QuantumCircuit(num_qubits)\n",
    "qc.isometry(rhs, list(range(num_qubits)), None)\n",
    "\n",
    "hhl = HHL()\n",
    "solution = hhl.solve(matrix, qc, observable)\n",
    "approx_result = solution.observable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83e61ca8",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(approx_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2b6197f",
   "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.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}