content/ch-applications/hhl_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "remove_cell"
    ]
   },
   "source": [
    "# Solving linear systems of equations using the HHL algorithm "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial, we introduce the HHL algorithm, derive the circuit, and implement it using Qiskit. We demonstrate how to run this algorithm on a simulator, as well as on a four-qubit device."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "contents"
    ]
   },
   "source": [
    "## Contents\n",
    "1. [Introduction](#introduction)\n",
    "2. [The HHL algorithm](#hhlalg)\n",
    "    1. [Conditions] (#conditions)\n",
    "    2. [Significance in Machine Learning] (#ml)\n",
    "    2. [Some mathematical background](#mathbackground)\n",
    "    3. [Description of the HHL](#hhldescription)\n",
    "    4. [Quantum Phase Estimation (QPE) within HHL](#qpe)\n",
    "    5. [Non-exact QPE](#qpe2)\n",
    "3. [Example 1: 4-qubit HHL](#example1)\n",
    "4. [Qiskit Implementation](#implementation)\n",
    "    1. [Running HHL on a simulator: general method](#implementationsim)\n",
    "    2. [Running HHL on a real quantum device: optimised example](#implementationdev)\n",
    "5. [Problems](#problems)\n",
    "6. [References](#references)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Introduction <a id='introduction'></a>\n",
    "\n",
    "Linear system of equations are ubiquitous throughout science and engineering, and, in every sector of research, manipulating matrices efficiently has become a massive area of interest. They arise naturally in many real-life applications in a wide range of areas, such as in the solution of Partial Differential Equations, the calibration of financial models, fluid simulation or numerical field calculation. \n",
    "\n",
    "Most classical methods for matrix manipulation do work in polynomial time, (unlike the classical solutions to the Deutsch-Jozsa and search problems that we've seen earlier). Unfortunately, as data analysis becomes more and more powerful, the size of these matrices can make even polynomial time too long. \n",
    "\n",
    "Developed by Aram Harrow, Avinatan Hassidim, and Seth Lloyd, HHL is a quantum algorithm that approximates a function of the solution vector of a linear system of equations, with running time complexity of $\\mathcal{ O }(\\log(N)s^{2}\\kappa^{2}/\\epsilon)$<sup>[1](#hhl)</sup>. This time reduction has significant implications for the speedup of many machine learning algorithms on quantum computers.\n",
    "\n",
    "The problem can be defined as, given a matrix $A\\in\\mathbb{C}^{N\\times N}$ and a vector $\\vec{b}\\in\\mathbb{C}^{N}$, find $\\vec{x}\\in\\mathbb{C}^{N}$ satisfying $A\\vec{x}=\\vec{b}$\n",
    "\n",
    "For example, take $N=2$, \n",
    "\n",
    "$$A = \\begin{pmatrix}1 & -1/3\\\\-1/3 & 1 \\end{pmatrix},\\quad \\vec{x}=\\begin{pmatrix} x_{1}\\\\ x_{2}\\end{pmatrix}\\quad \\text{and} \\quad \\vec{b}=\\begin{pmatrix}1 \\\\ 0\\end{pmatrix}$$\n",
    "\n",
    "Hence, the problem can be written as find $x_{1}, x_{2}\\in\\mathbb{C}$ such that\n",
    "$$\\begin{cases}x_{1} - \\frac{x_{2}}{3} = 1 \\\\ -\\frac{x_{1}}{3} + x_{2} = 0\\end{cases} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. The HHL algorithm<a id='hhlalg'></a>\n",
    "\n",
    "### A. Conditions <a id='conditions'></a>\n",
    "The given Linear system has to have a low condition number ${\\displaystyle \\kappa },$ and the Matrix $A$ must be $s$-sparse. This means $A$ must have at most $s$ non-zero entries per row or column. Solving an $s$-sparse system of size $N$ with a classical computer requires $\\mathcal{ O }(Ns\\kappa\\log(1/\\epsilon))$ running time using the conjugate gradient method <sup>[2](#conjgrad)</sup>. Here, $\\epsilon$ deonotes the accuracy of the approximation.\n",
    " \n",
    "It is assumed that the user of the algorithm is interested in the result of a scalar measurement on the solution vector, instead of the values of the solution vector itself. So, it assumes that the user is not interested in the values of ${\\displaystyle {\\overrightarrow {x}}}$ itself, but rather the result of applying some operator ${\\displaystyle M}$ onto x, ${\\displaystyle \\langle x|M|x\\rangle }$. Hence, while the classical algorithm returns the full solution, the HHL can only approximate functions of the solution vector.\n",
    "\n",
    "Also, Matrix ${\\displaystyle A}$ should be Hermitian so that it can be converted into a unitary operator, under the assumptions of efficient oracles for loading the data, Hamiltonian simulation and computing a function of the solution. \n",
    "\n",
    "### B. Significance in Machine Learning<a id='ml'></a>\n",
    "The time required for a least-squares fit (a continuous function to model a set of discrete points) has been found to become very large as the amount of discrete points increases. However, a research group has developed a quantum algorithm that incorporates HHL to solve many cases of least-squares efficiently, eliminating the need for the previously best higher-complexity algorithm <sup>[3](#ml)</sup>.\n",
    "\n",
    "Of course, HHL is thought to be massively useful in machine learning, where classical algorithms are limited by a polynomial dependence on the volume of data and dimensions of the space. One specific use for HHL in machine learning is in an optimized linear or non-linear binary classifier, or support vector machine. Research has shown that a quantum support vector machine can be used for big data classification and achieve an exponential speedup over classical computers <sup>[4](#data)</sup> . A quantum algorithm has also been developed for Bayesian training of deep neural networks, with an exponential speedup over classical training due to the use of HHL.\n",
    "\n",
    "\n",
    "### C. Some mathematical background<a id='mathbackground'></a>\n",
    "The first step towards solving a system of linear equations with a quantum computer is to encode the problem in the quantum language. By rescaling the system, we can assume $\\vec{b}$ and $\\vec{x}$ to be normalised and map them to the respective quantum states $|b\\rangle$ and $|x\\rangle$. Usually the mapping used is such that $i^{th}$ component of $\\vec{b}$ (resp. $\\vec{x}$) corresponds to the amplitude of the $i^{th}$ basis state of the quantum state $|b\\rangle$ (resp. $|x\\rangle$). From now on, we will focus on the rescaled problem\n",
    "\n",
    "$$ A|x\\rangle=|b\\rangle$$\n",
    "\n",
    "Since $A$ is Hermitian, it has a spectral decomposition\n",
    "$$\n",
    "A=\\sum_{j=0}^{N-1}\\lambda_{j}|u_{j}\\rangle\\langle u_{j}|,\\quad \\lambda_{j}\\in\\mathbb{ R }\n",
    "$$\n",
    "where $|u_{j}\\rangle$ is the $j^{th}$ eigenvector of $A$ with respective eigenvalue $\\lambda_{j}$.  It can be written as a the sum of the outer products of its eigenvectors, scaled by its eigenvalues. Therefore, we can write the inverse of A as\n",
    "$$A^{-1}=\\sum_{j=0}^{N-1}\\lambda_{j}^{-1}|u_{j}\\rangle\\langle u_{j}|\n",
    "$$\n",
    "Since $A$ is invertible and Hermitian, it must have an orthogonal basis of eigenvectors, and thus we can write $b$ in the eigenbasis of $A$ as\n",
    "$$\n",
    "|b\\rangle=\\sum_{j=0}^{N-1}b_{j}|u_{j}\\rangle,\\quad b_{j}\\in\\mathbb{ C }\n",
    "$$\n",
    "It is useful to keep in mind that the goal of the HHL is to exit the algorithm with the readout register in the state\n",
    "$$\n",
    "|x\\rangle=A^{-1}|b\\rangle=\\sum_{j=0}^{N-1}\\lambda_{j}^{-1}b_{j}|u_{j}\\rangle\n",
    "$$\n",
    "Note that here we already have an implicit normalisation constant since we are talking about a quantum state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### D. Description of the HHL algorithm <a id='hhldescription'></a>\n",
    "\n",
    "The algorithm uses three quantum registers, all of them set to $|0\\rangle $ at the beginning of the algorithm. One register, which we will denote with the subindex $n_{l}$, is used to store a binary representation of the eigenvalues of $A$. A second register, denoted by $n_{b}$, contains the vector solution, and from now on $N=2^{n_{b}}$. There is an extra register, for the auxiliary qubits. These are qubits used as intermediate steps in the individual computations but will be ignored in the following description since they are set to $|0\\rangle $ at the beginning of each computation and restored back to the $|0\\rangle $ state at the end of the individual operation.\n",
    "\n",
    "The following is an outline of the HHL algorithm with a high-level drawing of the corresponding circuit. For simplicity all computations are assumed to be exact in the ensuing description, and a more detailed explanation of the non-exact case is given in Section [2.D.](#qpe2).\n",
    "\n",
    "<img src=\"images/hhlcircuit.png\" width = \"75%\" height = \"75%\">\n",
    "\n",
    "1.  Load the data $|b\\rangle\\in\\mathbb{ C }^{N}$. That is, perform the transformation\n",
    "    $$ |0\\rangle _{n_{b}} \\mapsto |b\\rangle _{n_{b}} $$\n",
    "2. Apply Quantum Phase Estimation (QPE) with\n",
    "\t$$\n",
    "\tU = e ^ { i A t } := \\sum _{j=0}^{N-1}e ^ { i \\lambda _ { j } t } |u_{j}\\rangle\\langle u_{j}|\n",
    "\t$$\n",
    "\tThe quantum state of the register expressed in the eigenbasis of $A$ is now\n",
    "\t$$\n",
    "\t\\sum_{j=0}^{N-1} b _ { j } |\\lambda _ {j }\\rangle_{n_{l}} |u_{j}\\rangle_{n_{b}}\n",
    "\t$$\n",
    "    where $|\\lambda _ {j }\\rangle_{n_{l}}$ is the $n_{l}$-bit binary representation of $\\lambda _ {j }$.\n",
    "    \n",
    "3. Add an auxiliary qubit and apply a rotation conditioned on $|\\lambda_{ j }\\rangle$,\n",
    "\t$$\n",
    "\t\\sum_{j=0}^{N-1} b _ { j } |\\lambda _ { j }\\rangle_{n_{l}}|u_{j}\\rangle_{n_{b}} \\left( \\sqrt { 1 - \\frac { C^{2}  } { \\lambda _ { j } ^ { 2 } } } |0\\rangle + \\frac { C } { \\lambda _ { j } } |1\\rangle \\right)\n",
    "\t$$\n",
    "\twhere $C$ is a normalisation constant, and, as expressed in the current form above, should be less than the smallest eigenvalue $\\lambda_{min}$ in magnitude, i.e., $|C| < \\lambda_{min}$.\n",
    "    \n",
    "4. Apply QPE$^{\\dagger}$. Ignoring possible errors from QPE, this results in\n",
    "\t$$\n",
    "\t\\sum_{j=0}^{N-1} b _ { j } |0\\rangle_{n_{l}}|u_{j}\\rangle_{n_{b}} \\left( \\sqrt { 1 - \\frac {C^{2}  } { \\lambda _ { j } ^ { 2 } } } |0\\rangle + \\frac { C } { \\lambda _ { j } } |1\\rangle \\right)\n",
    "\t$$\n",
    "    \n",
    "5. Measure the auxiliary qubit in the computational basis. If the outcome is $1$, the register is in the post-measurement state\n",
    "\t$$\n",
    "\t\\left( \\sqrt { \\frac { 1 } { \\sum_{j=0}^{N-1} \\left| b _ { j } \\right| ^ { 2 } / \\left| \\lambda _ { j } \\right| ^ { 2 } } } \\right) \\sum _{j=0}^{N-1} \\frac{b _ { j }}{\\lambda _ { j }} |0\\rangle_{n_{l}}|u_{j}\\rangle_{n_{b}}\n",
    "\t$$\n",
    "\twhich up to a normalisation factor corresponds to the solution.\n",
    "\n",
    "6. Apply an observable $M$ to calculate $F(x):=\\langle x|M|x\\rangle$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### E. Quantum Phase Estimation (QPE) within HHL <a id='qpe'></a>\n",
    "\n",
    "Quantum Phase Estimation is described in more detail in Chapter 3. However, since this quantum procedure is at the core of the HHL algorithm, we recall here the definition. Roughly speaking, it is a quantum algorithm which, given a unitary $U$ with eigenvector $|\\psi\\rangle_{m}$ and eigenvalue $e^{2\\pi i\\theta}$, finds $\\theta$. We can formally define this as follows.\n",
    "\n",
    "**Definition:** Let $U\\in\\mathbb{ C }^{2^{m}\\times 2^{m}}$ be unitary and let $|\\psi\\rangle_{m}\\in\\mathbb{ C }^{2^{m}}$ be one of its eigenvectors with respective eigenvalue $e^{2\\pi i\\theta}$. The **Quantum Phase Estimation** algorithm, abbreviated **QPE**, takes as inputs the unitary gate for $U$ and the state $|0\\rangle_{n}|\\psi\\rangle_{m}$ and returns the state $|\\tilde{\\theta}\\rangle_{n}|\\psi\\rangle_{m}$. Here $\\tilde{\\theta}$ denotes a binary approximation to $2^{n}\\theta$ and the $n$ subscript denotes it has been truncated to $n$ digits.\t\n",
    "$$\n",
    "\\operatorname { QPE } ( U , |0\\rangle_{n}|\\psi\\rangle_{m} ) = |\\tilde{\\theta}\\rangle_{n}|\\psi\\rangle_{m}\n",
    "$$\n",
    "\n",
    "For the HHL we will use QPE with $U = e ^ { i A t }$, where $A$ is the matrix associated to the system we want to solve. In this case, \n",
    "$$\n",
    "e ^ { i A t } = \\sum_{j=0}^{N-1}e^{i\\lambda_{j}t}|u_{j}\\rangle\\langle u_{j}|\n",
    "$$\n",
    "Then, for the eigenvector $|u_{j}\\rangle_{n_{b}}$, which has eigenvalue $e ^ { i \\lambda _ { j } t }$, QPE will output $|\\tilde{\\lambda }_ { j }\\rangle_{n_{l}}|u_{j}\\rangle_{n_{b}}$. Where $\\tilde{\\lambda }_ { j }$ represents an $n_{l}$-bit binary approximation to $2^{n_l}\\frac{\\lambda_ { j }t}{2\\pi}$. Therefore, if each $\\lambda_{j}$ can be exactly represented with $n_{l}$ bits,\n",
    "$$\n",
    "\\operatorname { QPE } ( e ^ { i A t } , \\sum_{j=0}^{N-1}b_{j}|0\\rangle_{n_{l}}|u_{j}\\rangle_{n_{b}} ) = \\sum_{j=0}^{N-1}b_{j}|\\lambda_{j}\\rangle_{n_{l}}|u_{j}\\rangle_{n_{b}}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### F. Non-exact QPE <a id='qpe2'></a>\n",
    "\n",
    "In reality, the quantum state of the register after applying QPE to the initial state is\n",
    "$$\n",
    "\\sum _ { j=0 }^{N-1} b _ { j } \\left( \\sum _ { l = 0 } ^ { 2 ^ { n_{l} } - 1 } \\alpha _ { l | j } |l\\rangle_{n_{l}} \\right)|u_{j}\\rangle_{n_{b}}\n",
    "$$\n",
    "where\n",
    "$$\n",
    "\\alpha _ { l | j } = \\frac { 1 } { 2 ^ { n_{l} } } \\sum _ { k = 0 } ^ { 2^{n_{l}}- 1 } \\left( e ^ { 2 \\pi i \\left( \\frac { \\lambda _ { j } t } { 2 \\pi } - \\frac { l } { 2 ^ { n_{l} } } \\right) } \\right) ^ { k }\n",
    "$$\n",
    "\n",
    "Denote by $\\tilde{\\lambda_{j}}$ the best $n_{l}$-bit approximation to $\\lambda_{j}$, $1\\leq j\\leq N$. Then we can relabel the $n_{l}$-register so that $\\alpha _ { l | j }$ denotes the amplitude of $|l + \\tilde { \\lambda } _ { j } \\rangle_{n_{l}}$. So now,\n",
    "$$\n",
    "\\alpha _ { l | j } : = \\frac { 1 } { 2 ^ { n_{l}} } \\sum _ { k = 0 } ^ { 2 ^ { n_{l} } - 1 } \\left( e ^ { 2 \\pi i \\left( \\frac { \\lambda _ { j } t } { 2 \\pi } - \\frac { l + \\tilde { \\lambda } _ { j } } { 2 ^ { n_{l} } } \\right) } \\right) ^ { k }\n",
    "$$\n",
    "If each $\\frac { \\lambda _ { j } t } { 2 \\pi }$ can be represented exactly with $n_{l}$ binary bits, then $\\frac { \\lambda _ { j } t } { 2 \\pi }=\\frac { \\tilde { \\lambda } _ { j } } { 2 ^ { n_{l} } }$ $\\forall j$. Therefore in this case $\\forall j$, $1\\leq j \\leq N$, it holds that $\\alpha _ { 0 | j } = 1$ and $\\alpha _ { l | j } = 0 \\quad \\forall l \\neq 0$. Only in this case we can write that the state of the register after QPE is \n",
    "$$\n",
    "\t\\sum_{j=0}^{N-1} b _ { j } |\\lambda _ {j }\\rangle_{n_{l}} |u_{j}\\rangle_{n_{b}}\n",
    "$$\n",
    "Otherwise, $|\\alpha _ { l | j }|$ is large if and only if $\\frac { \\lambda _ { j } t } { 2 \\pi } \\approx \\frac { l + \\tilde { \\lambda } _ { j } } { 2 ^ { n_{l} } }$ and the state of the register is\n",
    "$$\n",
    "\\sum _ { j=0 }^{N-1}  \\sum _ { l = 0 } ^ { 2 ^ { n_{l} } - 1 } \\alpha _ { l | j } b _ { j }|l\\rangle_{n_{l}} |u_{j}\\rangle_{n_{b}}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Example: 4-qubit HHL<a id='example1'></a>\n",
    "\n",
    "Let's take the small example from the introduction to illustrate the algorithm. That is,\n",
    "$$A = \\begin{pmatrix}1 & -1/3\\\\-1/3 & 1 \\end{pmatrix}\\quad \\text{and} \\quad |b\\rangle=\\begin{pmatrix}1 \\\\ 0\\end{pmatrix}$$\n",
    "\n",
    "We will use $n_{b}=1$ qubit to represent $|b\\rangle$, and later the solution $|x\\rangle$, $n_{l}=2$ qubits to store the binary representation of the eigenvalues and $1$ auxiliary qubit to store whether the conditioned rotation, hence the algorithm, was successful.\n",
    "\n",
    "For the purpose of illustrating the algorithm, we will cheat a bit and calculate the eigenvalues of $A$ to be able to choose $t$ to obtain an exact binary representation of the rescaled eigenvalues in the $n_{l}$-register. However, keep in mind that for the HHL algorithm implementation one does not need previous knowledge of the eigenvalues. Having said that, a short calculation will give\n",
    "$$\\lambda_{1} = 2/3\\quad\\text{and}\\quad\\lambda_{2}=4/3$$\n",
    "\n",
    "Recall from the previous section that the QPE will output an $n_{l}$-bit ($2$-bit in this case) binary approximation to $\\frac{\\lambda_ { j }t}{2\\pi}$. Therefore, if we set \n",
    "$$t=2\\pi\\cdot \\frac{3}{8}$$\n",
    "the QPE will give a $2$-bit binary approximation to\n",
    "$$\\frac{\\lambda_ { 1 }t}{2\\pi} = 1/4\\quad\\text{and}\\quad\\frac{\\lambda_ { 2 }t}{2\\pi}=1/2$$\n",
    "which is, respectively,\n",
    "$$|01\\rangle_{n_{l}}\\quad\\text{and}\\quad|10\\rangle_{n_{l}}$$\n",
    "\n",
    "The eigenvectors are, respectively,\n",
    "$$|u_{1}\\rangle=\\frac{1}{\\sqrt{2}}\\begin{pmatrix}1 \\\\ -1\\end{pmatrix}\\quad\\text{and}\\quad|u_{2}\\rangle=\\frac{1}{\\sqrt{2}}\\begin{pmatrix}1 \\\\ 1\\end{pmatrix}$$\n",
    "Again, keep in mind that one does not need to compute the eigenvectors for the HHL implementation. In fact, a general Hermitian matrix $A$ of dimension $N$ can have up to $N$ different eigenvalues, therefore calculating them would take $\\mathcal{O}(N)$ time and the quantum advantage would be lost.\n",
    "\n",
    "We can then write $|b\\rangle$ in the eigenbasis of $A$ as\n",
    "$$|b\\rangle _{n_{b}}=\\sum_{j=1}^{2}\\frac{1}{\\sqrt{2}}|u_{j}\\rangle _{n_{b}}$$\n",
    "\n",
    "Now we are ready to go through the different steps of the HHL algorithm. \n",
    "\n",
    "1. State preparation in this example is trivial since $|b\\rangle=|0\\rangle$.\n",
    "2. Applying QPE will yield\n",
    "$$\n",
    "\\frac{1}{\\sqrt{2}}|01\\rangle|u_{1}\\rangle + \\frac{1}{\\sqrt{2}}|10\\rangle|u_{2}\\rangle\n",
    "$$\n",
    "3. Conditioned rotation with $C=1/8$ that is less than the smallest (rescaled) eigenvalue of $\\frac {1} {4}$. Note, the constant $C$ here needs to be chosen such that it is less than the smallest (rescaled) eigenvalue of $\\frac {1} {4}$ but as large as possible so that when the auxiliary qubit is measured, the probability of it being in the state $|1>$ is large.\n",
    "$$\\frac{1}{\\sqrt{2}}|01\\rangle|u_{1}\\rangle\\left( \\sqrt { 1 - \\frac { (1/8)^{2}  } {(1/4)^{2} } } |0\\rangle + \\frac { 1/8 } { 1/4 } |1\\rangle \\right) + \\frac{1}{\\sqrt{2}}|10\\rangle|u_{2}\\rangle\\left( \\sqrt { 1 - \\frac { (1/8)^{2}  } {(1/2)^{2} } } |0\\rangle + \\frac { 1/8 } { 1/2 } |1\\rangle \\right)\n",
    "$$\n",
    "$$\n",
    "=\\frac{1}{\\sqrt{2}}|01\\rangle|u_{1}\\rangle\\left( \\sqrt { 1 - \\frac { 1  } {4 } } |0\\rangle + \\frac { 1 } { 2 } |1\\rangle \\right) + \\frac{1}{\\sqrt{2}}|10\\rangle|u_{2}\\rangle\\left( \\sqrt { 1 - \\frac { 1  } {16 } } |0\\rangle + \\frac { 1 } { 4 } |1\\rangle \\right)\n",
    "$$\n",
    "4. After applying QPE$^{\\dagger}$ the quantum computer is in the state\n",
    "$$\n",
    "\\frac{1}{\\sqrt{2}}|00\\rangle|u_{1}\\rangle\\left( \\sqrt { 1 - \\frac { 1  } {4 } } |0\\rangle + \\frac { 1 } { 2 } |1\\rangle \\right) + \\frac{1}{\\sqrt{2}}|00\\rangle|u_{2}\\rangle\\left( \\sqrt { 1 - \\frac { 1  } {16 } } |0\\rangle + \\frac { 1 } { 4 } |1\\rangle \\right)\n",
    "$$\n",
    "5. On outcome $1$ when measuring the auxiliary qubit, the state is \n",
    "$$\n",
    "\\frac{\\frac{1}{\\sqrt{2}}|00\\rangle|u_{1}\\rangle\\frac { 1 } { 2 } |1\\rangle + \\frac{1}{\\sqrt{2}}|00\\rangle|u_{2}\\rangle\\frac { 1 } { 4 } |1\\rangle}{\\sqrt{5/32}}\n",
    "$$\n",
    "A quick calculation shows that\n",
    "$$\n",
    "\\frac{\\frac{1}{2\\sqrt{2}}|u_{1}\\rangle+ \\frac{1}{4\\sqrt{2}}|u_{2}\\rangle}{\\sqrt{5/32}} = \\frac{|x\\rangle}{||x||}\n",
    "$$\n",
    "6. Without using extra gates, we can compute the norm of $|x\\rangle$: it is the probability of measuring $1$ in the auxiliary qubit from the previous step.\n",
    "$$\n",
    "P(|1\\rangle) = \\left(\\frac{1}{2\\sqrt{2}}\\right)^{2} + \\left(\\frac{1}{4\\sqrt{2}}\\right)^{2} = \\frac{5}{32} = ||x||^{2}\n",
    "$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Qiskit Implementation<a id='implementation'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have analytically solved the problem from the example we are going to use it to illustrate how to run the HHL on a quantum simulator and on the real hardware. For the quantum simulator, Qiskit already provides an implementation of the HHL algorithm requiring only the matrix $A$ and $|b\\rangle$ as inputs in the simplest example. Although we can give the algorithm a general Hermitian matrix and an arbitrary initial state as NumPy arrays, in these cases the quantum algorithm will not achieve an exponential speedup. This is because the default implementation is exact and therefore exponential in the number of qubits (there is no algorithm that can prepare exactly an arbitrary quantum state using polynomial resources in the number of qubits or that can perform exactly the operation $e^{iAt}$ for some general Hermitian matrix $A$ using polynomial resources in the number of qubits). If we know an efficient implementation for a particular problem, the matrix and/or the vector can be given as `QuantumCircuit` objects. Alternatively, there's already an efficient implementation for tridiagonal Toeplitz matrices and in the future there might be more.\n",
    "\n",
    "However, at the time of writing the existing quantum computers are noisy and can only run small circuits. Therefore, in Section [4.B.](#implementationdev) we will see an optimised circuit that can be used for a class of problems to which our example belongs and mention the existing procedures to deal with noise in quantum computers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A. Running HHL on a simulator: general method<a id='implementationsim'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The interface for all algorithms to solve the linear system problem is `LinearSolver`. The problem to be solved is only specified when the `solve()` method is called:\n",
    "```python\n",
    "LinearSolver(...).solve(matrix, vector)\n",
    "```\n",
    "\n",
    "The simplest implementation takes the matrix and the vector as NumPy arrays. Below we also create a `NumPyLinearSolver` (the classical algorithm) to validate our solutions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from qiskit.algorithms.linear_solvers.numpy_linear_solver import NumPyLinearSolver\n",
    "from qiskit.algorithms.linear_solvers.hhl import HHL\n",
    "matrix = np.array([[1, -1/3], [-1/3, 1]])\n",
    "vector = np.array([1, 0])\n",
    "naive_hhl_solution = HHL().solve(matrix, vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the classical solver we need to rescale the right hand side (i.e. `vector / np.linalg.norm(vector)`) to take into account the renormalisation that occurs once `vector` is encoded in a quantum state within HHL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "classical_solution = NumPyLinearSolver().solve(matrix, vector / np.linalg.norm(vector))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `linear_solvers` package contains a folder called `matrices` intended to be a placeholder for efficient implementations of particular types of matrices. At the time of writing the only truly efficient implementation it contains (i.e. complexity scaling polynomially in the number of qubits) is the `TridiagonalToeplitz` class. Tridiagonal Toeplitz symmetric real matrices are of the following form \n",
    "$$A = \\begin{pmatrix}a & b & 0 & 0\\\\b & a & b & 0 \\\\ 0 & b & a & b \\\\ 0 & 0 & b & a \\end{pmatrix}, a,b\\in\\mathbb{R}$$\n",
    "(note that in this setting we do not consider non symmetric matrices since the HHL algorithm assumes that the input matrix is Hermitian).\n",
    "\n",
    "Since the matrix $A$ from our example is of this form we can create an instance of `TridiagonalToeplitz(num_qubits, a, b)` and compare the results to solving the system with an array as input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.algorithms.linear_solvers.matrices.tridiagonal_toeplitz import TridiagonalToeplitz\n",
    "tridi_matrix = TridiagonalToeplitz(1, 1, -1 / 3)\n",
    "\n",
    "tridi_solution = HHL().solve(tridi_matrix, vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that the HHL algorithm can find a solution exponentially faster in the size of the system than their classical counterparts (i.e. logarithmic complexity instead of polynomial). However the cost for this exponential speedup is that we do not obtain the full solution vector.\n",
    "Instead, we obtain a quantum state representing the vector $x$ and learning all the components of this vector would take a linear time in its dimension, diminishing any speedup obtained by the quantum algorithm.\n",
    "\n",
    "Therefore, we can only compute functions from $x$ (the so called observables) to learn information about the solution.\n",
    "This is reflected in the `LinearSolverResult` object returned by `solve()`, which contains the following properties\n",
    "- `state`: either the circuit that prepares the solution or the solution as a vector\n",
    "- `euclidean_norm`: the euclidean norm if the algorithm knows how to calculate it \n",
    "- `observable`: the (list of) calculated observable(s)\n",
    "- `circuit_results`: the observable results from the (list of) circuit(s)\n",
    "\n",
    "Let's ignore `observable` and `circuit_results` for the time being and check the solutions we obtained before.\n",
    "\n",
    "First, `classical_solution` was the result from a classical algorithm, so if we call `.state` it will return an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "classical state: [1.125 0.375]\n"
     ]
    }
   ],
   "source": [
    "print('classical state:', classical_solution.state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our other two examples were quantum algorithms, hence we can only access to the quantum state. This is achieved by returning the quantum circuit that prepares the solution state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive state:\n",
      "      ┌────────────┐┌──────┐        ┌─────────┐\n",
      "  q4: ┤ circuit-85 ├┤3     ├────────┤3        ├\n",
      "      └────────────┘│      │┌──────┐│         │\n",
      "q5_0: ──────────────┤0     ├┤2     ├┤0        ├\n",
      "                    │  QPE ││      ││  QPE_dg │\n",
      "q5_1: ──────────────┤1     ├┤1     ├┤1        ├\n",
      "                    │      ││  1/x ││         │\n",
      "q5_2: ──────────────┤2     ├┤0     ├┤2        ├\n",
      "                    └──────┘│      │└─────────┘\n",
      "  q6: ──────────────────────┤3     ├───────────\n",
      "                            └──────┘           \n",
      "tridiagonal state:\n",
      "       ┌─────────────┐┌──────┐        ┌─────────┐\n",
      "  q26: ┤ circuit-298 ├┤3     ├────────┤3        ├\n",
      "       └─────────────┘│      │┌──────┐│         │\n",
      "q27_0: ───────────────┤0     ├┤2     ├┤0        ├\n",
      "                      │  QPE ││      ││  QPE_dg │\n",
      "q27_1: ───────────────┤1     ├┤1     ├┤1        ├\n",
      "                      │      ││  1/x ││         │\n",
      "q27_2: ───────────────┤2     ├┤0     ├┤2        ├\n",
      "                      └──────┘│      │└─────────┘\n",
      "  q28: ───────────────────────┤3     ├───────────\n",
      "                              └──────┘           \n"
     ]
    }
   ],
   "source": [
    "print('naive state:')\n",
    "print(naive_hhl_solution.state)\n",
    "print('tridiagonal state:')\n",
    "print(tridi_solution.state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that the Euclidean norm for a vector $\\mathbf{x}=(x_1,\\dots,x_N)$ is defined as $||\\mathbf{x}||=\\sqrt{\\sum_{i=1}^N x_i^2}$. Therefore, the probability of measuring $1$ in the auxiliary qubit from Step $5$ in Section B is the squared norm of $\\mathbf{x}$. This means that the HHL algorithm can always calculate the euclidean norm of the solution and we can compare the accuracy of the results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "classical Euclidean norm: 1.1858541225631423\n",
      "naive Euclidean norm: 1.185854122563138\n",
      "tridiagonal Euclidean norm: 1.1858541225631365\n"
     ]
    }
   ],
   "source": [
    "print('classical Euclidean norm:', classical_solution.euclidean_norm)\n",
    "print('naive Euclidean norm:', naive_hhl_solution.euclidean_norm)\n",
    "print('tridiagonal Euclidean norm:', tridi_solution.euclidean_norm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparing the solution vectors componentwise is more tricky, reflecting again the idea that we cannot obtain the full solution vector from the quantum algorithm. However, for educational purposes we can check that indeed the different solution vectors obtained are a good approximation at the vector component level as well. \n",
    "\n",
    "To do so first we need to use `Statevector` from the `quantum_info` package and extract the right vector components, i.e. those corresponding to the ancillary qubit (bottom in the circuits) being $1$ and the work qubits (the two middle in the circuits) being $0$. Thus, we are interested in the states `1000` and `1001`, corresponding to the first and second components of the solution vector respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive raw solution vector: [ 7.01210122e-17-1.79155250e-17j -2.56134648e-17+4.69767668e-16j]\n",
      "tridi raw solution vector: [-2.25835328e-16+6.47049822e-17j -3.17703567e-17+6.25277055e-16j]\n"
     ]
    }
   ],
   "source": [
    "from qiskit.quantum_info import Statevector\n",
    "\n",
    "naive_sv = Statevector(naive_hhl_solution.state).data\n",
    "tridi_sv = Statevector(tridi_solution.state).data\n",
    "\n",
    "# Extract the right vector components. 1000 corresponds to the index 8 and 1001 corresponds to the index 9\n",
    "naive_full_vector = np.array([naive_sv[8], naive_sv[9]])\n",
    "tridi_full_vector = np.array([tridi_sv[8], tridi_sv[9]])\n",
    "\n",
    "print('naive raw solution vector:', naive_full_vector)\n",
    "print('tridi raw solution vector:', tridi_full_vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At a first glance it might seem that this is wrong because the components are complex numbers instead of reals. However note that the imaginary part is very small, most likely due to computer accuracy, and can be disregarded in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "naive_full_vector = np.real(naive_full_vector)\n",
    "tridi_full_vector = np.real(tridi_full_vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will divide the vectors by their respective norms to suppress any constants coming from the different parts of the circuits. The full solution vector can then be recovered by multiplying these normalised vectors by the respective Euclidean norms calculated above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "full naive solution vector: [ 1.11387047 -0.40686923]\n",
      "full tridi solution vector: [-1.17429105 -0.16519845]\n",
      "classical state: [1.125 0.375]\n"
     ]
    }
   ],
   "source": [
    "print('full naive solution vector:', naive_hhl_solution.euclidean_norm*naive_full_vector/np.linalg.norm(naive_full_vector))\n",
    "print('full tridi solution vector:', tridi_solution.euclidean_norm*tridi_full_vector/np.linalg.norm(tridi_full_vector))\n",
    "print('classical state:', classical_solution.state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It should not come as a surprise that `naive_hhl_solution` is exact because all the default methods used are exact. However, `tridi_solution` is exact only in the $2\\times 2$ system size case. For larger matrices it will be an approximation, as shown in the slightly larger example below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "classical euclidean norm: 1.237833351044751\n",
      "naive euclidean norm: 1.209980623111888\n",
      "tridiagonal euclidean norm: 1.2094577218705271\n"
     ]
    }
   ],
   "source": [
    "from scipy.sparse import diags\n",
    "\n",
    "num_qubits = 2\n",
    "matrix_size = 2 ** num_qubits\n",
    "# entries of the tridiagonal Toeplitz symmetric matrix\n",
    "a = 1\n",
    "b = -1/3\n",
    "\n",
    "matrix = diags([b, a, b], [-1, 0, 1], shape=(matrix_size, matrix_size)).toarray()\n",
    "vector = np.array([1] + [0]*(matrix_size - 1))\n",
    "\n",
    "# run the algorithms\n",
    "classical_solution = NumPyLinearSolver().solve(matrix, vector / np.linalg.norm(vector))\n",
    "naive_hhl_solution = HHL().solve(matrix, vector)\n",
    "tridi_matrix = TridiagonalToeplitz(num_qubits, a, b)\n",
    "tridi_solution = HHL().solve(tridi_matrix, vector)\n",
    "\n",
    "print('classical euclidean norm:', classical_solution.euclidean_norm)\n",
    "print('naive euclidean norm:', naive_hhl_solution.euclidean_norm)\n",
    "print('tridiagonal euclidean norm:', tridi_solution.euclidean_norm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also compare the difference in resources from the exact method and the efficient implementation. The $2\\times 2$ system size is again special in that the exact algorithm requires less resources, but as we increase the system size, we can see that indeed the exact method scales exponentially in the number of qubits while `TridiagonalToeplitz` is polynomial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import transpile\n",
    "\n",
    "num_qubits = list(range(1,5))\n",
    "a = 1\n",
    "b = -1/3\n",
    "\n",
    "i=1\n",
    "# calculate the circuit depths for different number of qubits to compare the use of resources\n",
    "naive_depths = []\n",
    "tridi_depths = []\n",
    "for nb in num_qubits:\n",
    "    matrix = diags([b, a, b], [-1, 0, 1], shape=(2**nb, 2**nb)).toarray()\n",
    "    vector = np.array([1] + [0]*(2**nb -1))\n",
    "    \n",
    "    naive_hhl_solution = HHL().solve(matrix, vector)\n",
    "    tridi_matrix = TridiagonalToeplitz(nb, a, b)\n",
    "    tridi_solution = HHL().solve(tridi_matrix, vector)\n",
    "\n",
    "    naive_qc = transpile(naive_hhl_solution.state,basis_gates=['id', 'rz', 'sx', 'x', 'cx'])\n",
    "    tridi_qc = transpile(tridi_solution.state,basis_gates=['id', 'rz', 'sx', 'x', 'cx'])\n",
    "    \n",
    "    naive_depths.append(naive_qc.depth())\n",
    "    tridi_depths.append(tridi_qc.depth())\n",
    "    i +=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     size of the system                    2x2                    4x4                    8x8                  16x16\n",
      " quantum_solution depth                    334                   2593                  34008                 403899\n",
      "   tridi_solution depth                    565                   5107                  14756                  46552\n"
     ]
    }
   ],
   "source": [
    "sizes = [str(2**nb)+\"x\"+str(2**nb) for nb in num_qubits]\n",
    "columns = ['size of the system', 'quantum_solution depth', 'tridi_solution depth']\n",
    "data = np.array([sizes, naive_depths, tridi_depths])\n",
    "row_format =\"{:>23}\" * (len(columns) + 2)\n",
    "for team, row in zip(columns, data):\n",
    "    print(row_format.format(team, *row))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reason the implementation still seems to need exponential resources is because the current conditioned rotation implementation (step 3 from Section 2.B) is exact (i.e. needs exponential resources in $n_l$). Instead we can calculate how many more resources the default implementation needs compared to Tridiagonal - since they only differ in how they implement $e^{iAt}$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "excess: [-231, -2514, 19252, 357347]\n"
     ]
    }
   ],
   "source": [
    "print('excess:', [naive_depths[i] - tridi_depths[i] for i in range(0, len(naive_depths))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the near future the plan is to integrate `qiskit.circuit.library.arithmetics.PiecewiseChebyshev` to obtain a polynomial implementation of the conditioned rotation as well.\n",
    "\n",
    "Now we can return to the topic of observables and find out what the `observable` and `circuit_results` properties contain.\n",
    "\n",
    "The way to compute functions of the solution vector $\\mathbf{x}$ is through giving the `.solve()` method a `LinearSystemObservable` as input. There are are two types of available `LinearSystemObservable` which can be given as input:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.algorithms.linear_solvers.observables import AbsoluteAverage, MatrixFunctional"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a vector $\\mathbf{x}=(x_1,...,x_N)$, the `AbsoluteAverage` observable computes $|\\frac{1}{N}\\sum_{i=1}^{N}x_i|$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "quantum average: 0.7499999999999962\n",
      "classical average: 0.75\n",
      "quantum circuit results: (0.4999999999999952+0j)\n"
     ]
    }
   ],
   "source": [
    "num_qubits = 1\n",
    "matrix_size = 2 ** num_qubits\n",
    "# entries of the tridiagonal Toeplitz symmetric matrix\n",
    "a = 1\n",
    "b = -1/3\n",
    "\n",
    "matrix = diags([b, a, b], [-1, 0, 1], shape=(matrix_size, matrix_size)).toarray()\n",
    "vector = np.array([1] + [0]*(matrix_size - 1))\n",
    "tridi_matrix = TridiagonalToeplitz(1, a, b)\n",
    "\n",
    "average_solution = HHL().solve(tridi_matrix, vector, AbsoluteAverage())\n",
    "classical_average = NumPyLinearSolver().solve(matrix, vector / np.linalg.norm(vector), AbsoluteAverage())\n",
    "\n",
    "print('quantum average:', average_solution.observable)\n",
    "print('classical average:', classical_average.observable)\n",
    "print('quantum circuit results:', average_solution.circuit_results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `MatrixFunctional` observable computes $\\mathbf{x}^T B \\mathbf{x}$ for a vector $\\mathbf{x}$ and a tridiagonal symmetric Toeplitz matrix $B$. The class takes the main and off diagonal values of the matrix for its constructor method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "quantum functional: 1.8281249999999818\n",
      "classical functional: 1.828125\n",
      "quantum circuit results: [(0.6249999999999941+0j), (0.4999999999999952+0j), (0.1249999999999988+0j)]\n"
     ]
    }
   ],
   "source": [
    "observable = MatrixFunctional(1, 1 / 2)\n",
    "\n",
    "functional_solution = HHL().solve(tridi_matrix, vector, observable)\n",
    "classical_functional = NumPyLinearSolver().solve(matrix, vector / np.linalg.norm(vector), observable)\n",
    "\n",
    "print('quantum functional:', functional_solution.observable)\n",
    "print('classical functional:', classical_functional.observable)\n",
    "print('quantum circuit results:', functional_solution.circuit_results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore, `observable` contains the final value of the function on $\\mathbf{x}$, while `circuit_results` contains the raw values obtained from the circuit and used to process the result of `observable`.\n",
    "\n",
    "This 'how to process the result' is better explained by looking at what arguments `.solve()` takes. The `solve()` method accepts up to five arguments: \n",
    "```python\n",
    "def solve(self, matrix: Union[np.ndarray, QuantumCircuit],\n",
    "          vector: Union[np.ndarray, QuantumCircuit],\n",
    "          observable: Optional[Union[LinearSystemObservable, BaseOperator,\n",
    "                                     List[BaseOperator]]] = None,\n",
    "          post_rotation: Optional[Union[QuantumCircuit, List[QuantumCircuit]]] = None,\n",
    "          post_processing: Optional[Callable[[Union[float, List[float]]],\n",
    "                                             Union[float, List[float]]]] = None) \\\n",
    "        -> LinearSolverResult:\n",
    "```\n",
    "The first two are the matrix defining the linear system and the vector right hand side of the equation, which we have already covered. The remaining parameters concern the (list of) observable(s) to be computed out of the solution vector $x$, and can be specified in two different ways. One option is to give as the third and last parameter a (list of) `LinearSystemObservable`(s). Alternatively, we can give our own implementations of the `observable`, `post_rotation` and `post_processing`, where\n",
    "- `observable` is the operator to compute the expected value of the observable and can be e.g. a `PauliSumOp`\n",
    "- `post_rotation` is the circuit to be applied to the solution to extract information if additional gates are needed.\n",
    "- `post_processing` is the function to compute the value of the observable from the calculated probabilities.\n",
    "\n",
    "In other words, there will be as many `circuit_results` as `post_rotation` circuits, and `post_processing` is telling the algorithm how to use the values we see when we print `circuit_results` to obtain the value we see when we print `observable`.\n",
    "\n",
    "Finally, the `HHL` class accepts the following parameters in its constructor method:\n",
    "- error tolerance : the accuracy of the approximation of the solution, the default is `1e-2`\n",
    "- expectation : how the expectation values are evaluated, the default is `PauliExpectation`\n",
    "- quantum instance: the `QuantumInstance` or backend, the default is a `Statevector` simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.185854122563138\n",
      "1.1858541225631423\n"
     ]
    }
   ],
   "source": [
    "from qiskit import Aer\n",
    "\n",
    "backend = Aer.get_backend('aer_simulator')\n",
    "hhl = HHL(1e-3, quantum_instance=backend)\n",
    "\n",
    "accurate_solution = hhl.solve(matrix, vector)\n",
    "classical_solution = NumPyLinearSolver().solve(matrix, vector / np.linalg.norm(vector))\n",
    "\n",
    "print(accurate_solution.euclidean_norm)\n",
    "print(classical_solution.euclidean_norm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## B. Running HHL on a real quantum device: optimised example<a id='implementationdev'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous section we ran the standard algorithm provided in Qiskit and saw that it uses $7$ qubits, has a depth of ~$100$ gates and requires a total of $54$ CNOT gates. These numbers are not feasible for the current available hardware, therefore we need to decrease these quantities. In particular, the goal will be to reduce the number of CNOTs by a factor of $5$ since they have worse fidelity than single-qubit gates. Furthermore, we can reduce the number of qubits to $4$ as was the original statement of the problem: the Qiskit method was written for a general problem and that is why it requires $3$ additional auxiliary qubits.\n",
    "\n",
    "However, solely decreasing the number of gates and qubits will not give a good approximation to the solution on real hardware. This is because there are two sources of errors: those that occur during the run of the circuit and readout errors. \n",
    "\n",
    "Qiskit provides a module to mitigate the readout errors by individually preparing and measuring all basis states, a detailed treatment on the topic can be found in the paper by Dewes et al.<sup>[4](#readouterr)</sup> To deal with the errors occurring during the run of the circuit, Richardson extrapolation can be used to calculate the error to the zero limit by running the circuit three times, each replacing each CNOT gate by $1$, $3$ and $5$ CNOTs respectively<sup>[5](#richardson)</sup>. The idea is that theoretically the three circuits should produce the same result, but in real hardware adding CNOTs means amplifying the error. Since we know that we have obtained results with an amplified error, and we can estimate by how much the error was amplified in each case, we can recombine the quantities to obtain a new result that is a closer approximation to the analytic solution than any of the previous obtained values.\n",
    "\n",
    "Below we give the optimised circuit that can be used for any problem of the form\n",
    "$$A = \\begin{pmatrix}a & b\\\\b & a \\end{pmatrix}\\quad \\text{and} \\quad |b\\rangle=\\begin{pmatrix}\\cos(\\theta) \\\\ \\sin(\\theta)\\end{pmatrix},\\quad a,b,\\theta\\in\\mathbb{R}$$\n",
    "\n",
    "The following optimisation was extracted from a work on the HHL for tridiagonal symmetric matrices<sup>[[6]](#tridi)</sup>, this particular circuit was derived with the aid of the UniversalQCompiler software<sup>[[7]](#qcompiler)</sup>.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Depth: 26\n",
      "CNOTS: 10\n"
     ]
    },
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       "  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<svg xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"1280.581975pt\" height=\"542.835593pt\" viewBox=\"0 0 1280.581975 542.835593\" xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">\n",
       " <metadata>\n",
       "  <rdf:RDF xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:cc=\"http://creativecommons.org/ns#\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n",
       "   <cc:Work>\n",
       "    <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\n",
       "    <dc:date>2022-09-05T15:12:15.121435</dc:date>\n",
       "    <dc:format>image/svg+xml</dc:format>\n",
       "    <dc:creator>\n",
       "     <cc:Agent>\n",
       "      <dc:title>Matplotlib v3.5.2, https://matplotlib.org/</dc:title>\n",
       "     </cc:Agent>\n",
       "    </dc:creator>\n",
       "   </cc:Work>\n",
       "  </rdf:RDF>\n",
       " </metadata>\n",
       " <defs>\n",
       "  <style type=\"text/css\">*{stroke-linejoin: round; stroke-linecap: butt}</style>\n",
       " </defs>\n",
       " <g id=\"figure_1\">\n",
       "  <g id=\"patch_1\">\n",
       "   <path d=\"M 0 542.835593 \n",
       "L 1280.581975 542.835593 \n",
       "L 1280.581975 0 \n",
       "L 0 0 \n",
       "z\n",
       "\" style=\"fill: #ffffff\"/>\n",
       "  </g>\n",
       "  <g id=\"axes_1\">\n",
       "   <g id=\"patch_2\">\n",
       "    <path d=\"M 216.974329 497.277658 \n",
       "L 229.026369 497.277658 \n",
       "L 223.000349 505.969033 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #778899\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_3\">\n",
       "    <path d=\"M 263.328328 497.277658 \n",
       "L 275.380368 497.277658 \n",
       "L 269.354348 505.969033 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #778899\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_4\">\n",
       "    <path d=\"M 309.682328 497.277658 \n",
       "L 321.734368 497.277658 \n",
       "L 315.708348 505.969033 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #778899\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_5\">\n",
       "    <path d=\"M 356.036327 497.277658 \n",
       "L 368.088367 497.277658 \n",
       "L 362.062347 505.969033 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #778899\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_1\">\n",
       "    <path d=\"M 105.26119 44.2832 \n",
       "L 1268.746575 44.2832 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #000000; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_2\">\n",
       "    <path d=\"M 105.26119 90.637199 \n",
       "L 1268.746575 90.637199 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #000000; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_3\">\n",
       "    <path d=\"M 105.26119 136.991198 \n",
       "L 1268.746575 136.991198 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #000000; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_4\">\n",
       "    <path d=\"M 105.26119 183.345198 \n",
       "L 1268.746575 183.345198 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #000000; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_5\">\n",
       "    <path d=\"M 105.26119 228.192692 \n",
       "L 1268.746575 228.192692 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #778899; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_6\">\n",
       "    <path d=\"M 105.26119 231.205702 \n",
       "L 1268.746575 231.205702 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #778899; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_7\">\n",
       "    <path d=\"M 105.26119 322.407196 \n",
       "L 1268.746575 322.407196 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #000000; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_8\">\n",
       "    <path d=\"M 105.26119 368.761195 \n",
       "L 1268.746575 368.761195 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #000000; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_9\">\n",
       "    <path d=\"M 105.26119 415.115195 \n",
       "L 1268.746575 415.115195 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #000000; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_10\">\n",
       "    <path d=\"M 105.26119 461.469194 \n",
       "L 1268.746575 461.469194 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #000000; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_11\">\n",
       "    <path d=\"M 105.26119 506.316688 \n",
       "L 1268.746575 506.316688 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #778899; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_12\">\n",
       "    <path d=\"M 105.26119 509.329698 \n",
       "L 1268.746575 509.329698 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #778899; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_13\">\n",
       "    <path d=\"M 114.53199 234.334597 \n",
       "L 119.16739 225.063797 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #778899; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_14\">\n",
       "    <path d=\"M 1268.746575 44.2832 \n",
       "L 1268.746575 229.699197 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #000000; stroke-width: 1.5; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_15\">\n",
       "    <path d=\"M 114.53199 512.458593 \n",
       "L 119.16739 503.187793 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #778899; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_16\">\n",
       "    <path d=\"M 104.79765 322.407196 \n",
       "L 104.79765 507.823193 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #000000; stroke-width: 1.5; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_17\">\n",
       "    <path d=\"M 315.708348 90.637199 \n",
       "L 315.708348 44.2832 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #1192e8; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_18\">\n",
       "    <path d=\"M 408.416346 90.637199 \n",
       "L 408.416346 44.2832 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #1192e8; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_19\">\n",
       "    <path d=\"M 593.832344 136.991198 \n",
       "L 593.832344 44.2832 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #1192e8; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_20\">\n",
       "    <path d=\"M 686.540343 136.991198 \n",
       "L 686.540343 44.2832 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #1192e8; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_21\">\n",
       "    <path d=\"M 825.602341 136.991198 \n",
       "L 825.602341 90.637199 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #1192e8; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_22\">\n",
       "    <path d=\"M 918.31034 136.991198 \n",
       "L 918.31034 90.637199 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #1192e8; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_23\">\n",
       "    <path d=\"M 964.664339 183.345198 \n",
       "L 964.664339 136.991198 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #1192e8; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_24\">\n",
       "    <path d=\"M 1057.372338 183.345198 \n",
       "L 1057.372338 90.637199 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #1192e8; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_25\">\n",
       "    <path d=\"M 1150.080337 183.345198 \n",
       "L 1150.080337 136.991198 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #1192e8; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_26\">\n",
       "    <path d=\"M 1242.788335 183.345198 \n",
       "L 1242.788335 90.637199 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #1192e8; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_6\">\n",
       "    <path d=\"M 167.60732 345.584196 \n",
       "L 185.685379 345.584196 \n",
       "L 185.685379 299.230196 \n",
       "L 167.60732 299.230196 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #bdbdbd; opacity: 0.6\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_7\">\n",
       "    <path d=\"M 167.60732 391.938195 \n",
       "L 185.685379 391.938195 \n",
       "L 185.685379 345.584196 \n",
       "L 167.60732 345.584196 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #bdbdbd; opacity: 0.6\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_8\">\n",
       "    <path d=\"M 167.60732 438.292194 \n",
       "L 185.685379 438.292194 \n",
       "L 185.685379 391.938195 \n",
       "L 167.60732 391.938195 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #bdbdbd; opacity: 0.6\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_9\">\n",
       "    <path d=\"M 167.60732 484.646194 \n",
       "L 185.685379 484.646194 \n",
       "L 185.685379 438.292194 \n",
       "L 167.60732 438.292194 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #bdbdbd; opacity: 0.6\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_27\">\n",
       "    <path d=\"M 224.506854 322.407196 \n",
       "L 224.506854 497.277658 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #778899; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_28\">\n",
       "    <path d=\"M 221.493844 322.407196 \n",
       "L 221.493844 497.277658 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #778899; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_29\">\n",
       "    <path d=\"M 270.860853 368.761195 \n",
       "L 270.860853 497.277658 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #778899; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_30\">\n",
       "    <path d=\"M 267.847843 368.761195 \n",
       "L 267.847843 497.277658 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #778899; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_31\">\n",
       "    <path d=\"M 317.214853 415.115195 \n",
       "L 317.214853 497.277658 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #778899; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_32\">\n",
       "    <path d=\"M 314.201843 415.115195 \n",
       "L 314.201843 497.277658 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #778899; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_33\">\n",
       "    <path d=\"M 363.568852 461.469194 \n",
       "L 363.568852 497.277658 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #778899; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_34\">\n",
       "    <path d=\"M 360.555842 461.469194 \n",
       "L 360.555842 497.277658 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #778899; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_10\">\n",
       "    <path d=\"M 115.2273 59.348249 \n",
       "L 145.3574 59.348249 \n",
       "L 145.3574 29.21815 \n",
       "L 115.2273 29.21815 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_11\">\n",
       "    <path d=\"M 115.2273 105.702249 \n",
       "L 145.3574 105.702249 \n",
       "L 145.3574 75.572149 \n",
       "L 115.2273 75.572149 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_12\">\n",
       "    <path d=\"M 115.2273 152.056248 \n",
       "L 145.3574 152.056248 \n",
       "L 145.3574 121.926148 \n",
       "L 115.2273 121.926148 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_13\">\n",
       "    <path d=\"M 184.758299 105.702249 \n",
       "L 214.888399 105.702249 \n",
       "L 214.888399 75.572149 \n",
       "L 184.758299 75.572149 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_14\">\n",
       "    <path d=\"M 184.758299 152.056248 \n",
       "L 214.888399 152.056248 \n",
       "L 214.888399 121.926148 \n",
       "L 184.758299 121.926148 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_15\">\n",
       "    <path d=\"M 161.773669 59.348249 \n",
       "L 237.87303 59.348249 \n",
       "L 237.87303 29.21815 \n",
       "L 161.773669 29.21815 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_16\">\n",
       "    <path d=\"M 254.289298 59.348249 \n",
       "L 284.419398 59.348249 \n",
       "L 284.419398 29.21815 \n",
       "L 254.289298 29.21815 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_17\">\n",
       "    <path d=\"M 315.708348 95.156714 \n",
       "C 316.906937 95.156714 318.056597 94.680509 318.904127 93.832979 \n",
       "C 319.751658 92.985448 320.227863 91.835788 320.227863 90.637199 \n",
       "C 320.227863 89.43861 319.751658 88.28895 318.904127 87.441419 \n",
       "C 318.056597 86.593889 316.906937 86.117684 315.708348 86.117684 \n",
       "C 314.509758 86.117684 313.360099 86.593889 312.512568 87.441419 \n",
       "C 311.665037 88.28895 311.188833 89.43861 311.188833 90.637199 \n",
       "C 311.188833 91.835788 311.665037 92.985448 312.512568 93.832979 \n",
       "C 313.360099 94.680509 314.509758 95.156714 315.708348 95.156714 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_18\">\n",
       "    <path d=\"M 315.708348 54.828734 \n",
       "C 318.505056 54.828734 321.187595 53.71759 323.165167 51.740019 \n",
       "C 325.142738 49.762447 326.253882 47.079908 326.253882 44.2832 \n",
       "C 326.253882 41.486491 325.142738 38.803952 323.165167 36.82638 \n",
       "C 321.187595 34.848809 318.505056 33.737665 315.708348 33.737665 \n",
       "C 312.911639 33.737665 310.2291 34.848809 308.251528 36.82638 \n",
       "C 306.273957 38.803952 305.162813 41.486491 305.162813 44.2832 \n",
       "C 305.162813 47.079908 306.273957 49.762447 308.251528 51.740019 \n",
       "C 310.2291 53.71759 312.911639 54.828734 315.708348 54.828734 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 2; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_19\">\n",
       "    <path d=\"M 346.174514 59.348249 \n",
       "L 377.95018 59.348249 \n",
       "L 377.95018 29.21815 \n",
       "L 346.174514 29.21815 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_20\">\n",
       "    <path d=\"M 408.416346 95.156714 \n",
       "C 409.614936 95.156714 410.764595 94.680509 411.612126 93.832979 \n",
       "C 412.459657 92.985448 412.935861 91.835788 412.935861 90.637199 \n",
       "C 412.935861 89.43861 412.459657 88.28895 411.612126 87.441419 \n",
       "C 410.764595 86.593889 409.614936 86.117684 408.416346 86.117684 \n",
       "C 407.217757 86.117684 406.068097 86.593889 405.220567 87.441419 \n",
       "C 404.373036 88.28895 403.896831 89.43861 403.896831 90.637199 \n",
       "C 403.896831 91.835788 404.373036 92.985448 405.220567 93.832979 \n",
       "C 406.068097 94.680509 407.217757 95.156714 408.416346 95.156714 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_21\">\n",
       "    <path d=\"M 408.416346 54.828734 \n",
       "C 411.213055 54.828734 413.895594 53.71759 415.873166 51.740019 \n",
       "C 417.850737 49.762447 418.961881 47.079908 418.961881 44.2832 \n",
       "C 418.961881 41.486491 417.850737 38.803952 415.873166 36.82638 \n",
       "C 413.895594 34.848809 411.213055 33.737665 408.416346 33.737665 \n",
       "C 405.619638 33.737665 402.937099 34.848809 400.959527 36.82638 \n",
       "C 398.981956 38.803952 397.870811 41.486491 397.870811 44.2832 \n",
       "C 397.870811 47.079908 398.981956 49.762447 400.959527 51.740019 \n",
       "C 402.937099 53.71759 405.619638 54.828734 408.416346 54.828734 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 2; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_22\">\n",
       "    <path d=\"M 439.705296 59.348249 \n",
       "L 469.835396 59.348249 \n",
       "L 469.835396 29.21815 \n",
       "L 439.705296 29.21815 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_23\">\n",
       "    <path d=\"M 486.059295 59.348249 \n",
       "L 516.189395 59.348249 \n",
       "L 516.189395 29.21815 \n",
       "L 486.059295 29.21815 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_24\">\n",
       "    <path d=\"M 532.413295 59.348249 \n",
       "L 562.543394 59.348249 \n",
       "L 562.543394 29.21815 \n",
       "L 532.413295 29.21815 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_25\">\n",
       "    <path d=\"M 593.832344 141.510713 \n",
       "C 595.030933 141.510713 596.180593 141.034509 597.028124 140.186978 \n",
       "C 597.875654 139.339447 598.351859 138.189788 598.351859 136.991198 \n",
       "C 598.351859 135.792609 597.875654 134.642949 597.028124 133.795419 \n",
       "C 596.180593 132.947888 595.030933 132.471683 593.832344 132.471683 \n",
       "C 592.633755 132.471683 591.484095 132.947888 590.636564 133.795419 \n",
       "C 589.789034 134.642949 589.312829 135.792609 589.312829 136.991198 \n",
       "C 589.312829 138.189788 589.789034 139.339447 590.636564 140.186978 \n",
       "C 591.484095 141.034509 592.633755 141.510713 593.832344 141.510713 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_26\">\n",
       "    <path d=\"M 593.832344 54.828734 \n",
       "C 596.629052 54.828734 599.311592 53.71759 601.289163 51.740019 \n",
       "C 603.266735 49.762447 604.377879 47.079908 604.377879 44.2832 \n",
       "C 604.377879 41.486491 603.266735 38.803952 601.289163 36.82638 \n",
       "C 599.311592 34.848809 596.629052 33.737665 593.832344 33.737665 \n",
       "C 591.035635 33.737665 588.353096 34.848809 586.375525 36.82638 \n",
       "C 584.397953 38.803952 583.286809 41.486491 583.286809 44.2832 \n",
       "C 583.286809 47.079908 584.397953 49.762447 586.375525 51.740019 \n",
       "C 588.353096 53.71759 591.035635 54.828734 593.832344 54.828734 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 2; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_27\">\n",
       "    <path d=\"M 625.121293 59.348249 \n",
       "L 655.251393 59.348249 \n",
       "L 655.251393 29.21815 \n",
       "L 625.121293 29.21815 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_28\">\n",
       "    <path d=\"M 686.540343 141.510713 \n",
       "C 687.738932 141.510713 688.888592 141.034509 689.736122 140.186978 \n",
       "C 690.583653 139.339447 691.059858 138.189788 691.059858 136.991198 \n",
       "C 691.059858 135.792609 690.583653 134.642949 689.736122 133.795419 \n",
       "C 688.888592 132.947888 687.738932 132.471683 686.540343 132.471683 \n",
       "C 685.341753 132.471683 684.192094 132.947888 683.344563 133.795419 \n",
       "C 682.497032 134.642949 682.020828 135.792609 682.020828 136.991198 \n",
       "C 682.020828 138.189788 682.497032 139.339447 683.344563 140.186978 \n",
       "C 684.192094 141.034509 685.341753 141.510713 686.540343 141.510713 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_29\">\n",
       "    <path d=\"M 686.540343 54.828734 \n",
       "C 689.337051 54.828734 692.01959 53.71759 693.997162 51.740019 \n",
       "C 695.974733 49.762447 697.085878 47.079908 697.085878 44.2832 \n",
       "C 697.085878 41.486491 695.974733 38.803952 693.997162 36.82638 \n",
       "C 692.01959 34.848809 689.337051 33.737665 686.540343 33.737665 \n",
       "C 683.743634 33.737665 681.061095 34.848809 679.083523 36.82638 \n",
       "C 677.105952 38.803952 675.994808 41.486491 675.994808 44.2832 \n",
       "C 675.994808 47.079908 677.105952 49.762447 679.083523 51.740019 \n",
       "C 681.061095 53.71759 683.743634 54.828734 686.540343 54.828734 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 2; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_30\">\n",
       "    <path d=\"M 717.829292 59.348249 \n",
       "L 747.959392 59.348249 \n",
       "L 747.959392 29.21815 \n",
       "L 717.829292 29.21815 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_31\">\n",
       "    <path d=\"M 717.829292 152.056248 \n",
       "L 747.959392 152.056248 \n",
       "L 747.959392 121.926148 \n",
       "L 717.829292 121.926148 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_32\">\n",
       "    <path d=\"M 764.183292 59.348249 \n",
       "L 794.313391 59.348249 \n",
       "L 794.313391 29.21815 \n",
       "L 764.183292 29.21815 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_33\">\n",
       "    <path d=\"M 764.183292 152.056248 \n",
       "L 794.313391 152.056248 \n",
       "L 794.313391 121.926148 \n",
       "L 764.183292 121.926148 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_34\">\n",
       "    <path d=\"M 825.602341 95.156714 \n",
       "C 826.80093 95.156714 827.95059 94.680509 828.79812 93.832979 \n",
       "C 829.645651 92.985448 830.121856 91.835788 830.121856 90.637199 \n",
       "C 830.121856 89.43861 829.645651 88.28895 828.79812 87.441419 \n",
       "C 827.95059 86.593889 826.80093 86.117684 825.602341 86.117684 \n",
       "C 824.403751 86.117684 823.254092 86.593889 822.406561 87.441419 \n",
       "C 821.55903 88.28895 821.082826 89.43861 821.082826 90.637199 \n",
       "C 821.082826 91.835788 821.55903 92.985448 822.406561 93.832979 \n",
       "C 823.254092 94.680509 824.403751 95.156714 825.602341 95.156714 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_35\">\n",
       "    <path d=\"M 825.602341 147.536733 \n",
       "C 828.399049 147.536733 831.081588 146.425589 833.05916 144.448017 \n",
       "C 835.036732 142.470446 836.147876 139.787907 836.147876 136.991198 \n",
       "C 836.147876 134.19449 835.036732 131.511951 833.05916 129.534379 \n",
       "C 831.081588 127.556807 828.399049 126.445663 825.602341 126.445663 \n",
       "C 822.805632 126.445663 820.123093 127.556807 818.145522 129.534379 \n",
       "C 816.16795 131.511951 815.056806 134.19449 815.056806 136.991198 \n",
       "C 815.056806 139.787907 816.16795 142.470446 818.145522 144.448017 \n",
       "C 820.123093 146.425589 822.805632 147.536733 825.602341 147.536733 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 2; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_36\">\n",
       "    <path d=\"M 856.89129 152.056248 \n",
       "L 887.02139 152.056248 \n",
       "L 887.02139 121.926148 \n",
       "L 856.89129 121.926148 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_37\">\n",
       "    <path d=\"M 918.31034 95.156714 \n",
       "C 919.508929 95.156714 920.658589 94.680509 921.506119 93.832979 \n",
       "C 922.35365 92.985448 922.829855 91.835788 922.829855 90.637199 \n",
       "C 922.829855 89.43861 922.35365 88.28895 921.506119 87.441419 \n",
       "C 920.658589 86.593889 919.508929 86.117684 918.31034 86.117684 \n",
       "C 917.11175 86.117684 915.962091 86.593889 915.11456 87.441419 \n",
       "C 914.267029 88.28895 913.790825 89.43861 913.790825 90.637199 \n",
       "C 913.790825 91.835788 914.267029 92.985448 915.11456 93.832979 \n",
       "C 915.962091 94.680509 917.11175 95.156714 918.31034 95.156714 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_38\">\n",
       "    <path d=\"M 918.31034 147.536733 \n",
       "C 921.107048 147.536733 923.789587 146.425589 925.767159 144.448017 \n",
       "C 927.74473 142.470446 928.855874 139.787907 928.855874 136.991198 \n",
       "C 928.855874 134.19449 927.74473 131.511951 925.767159 129.534379 \n",
       "C 923.789587 127.556807 921.107048 126.445663 918.31034 126.445663 \n",
       "C 915.513631 126.445663 912.831092 127.556807 910.85352 129.534379 \n",
       "C 908.875949 131.511951 907.764805 134.19449 907.764805 136.991198 \n",
       "C 907.764805 139.787907 908.875949 142.470446 910.85352 144.448017 \n",
       "C 912.831092 146.425589 915.513631 147.536733 918.31034 147.536733 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 2; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_39\">\n",
       "    <path d=\"M 949.599289 105.702249 \n",
       "L 979.729389 105.702249 \n",
       "L 979.729389 75.572149 \n",
       "L 949.599289 75.572149 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_40\">\n",
       "    <path d=\"M 964.664339 141.510713 \n",
       "C 965.862928 141.510713 967.012588 141.034509 967.860119 140.186978 \n",
       "C 968.707649 139.339447 969.183854 138.189788 969.183854 136.991198 \n",
       "C 969.183854 135.792609 968.707649 134.642949 967.860119 133.795419 \n",
       "C 967.012588 132.947888 965.862928 132.471683 964.664339 132.471683 \n",
       "C 963.46575 132.471683 962.31609 132.947888 961.468559 133.795419 \n",
       "C 960.621029 134.642949 960.144824 135.792609 960.144824 136.991198 \n",
       "C 960.144824 138.189788 960.621029 139.339447 961.468559 140.186978 \n",
       "C 962.31609 141.034509 963.46575 141.510713 964.664339 141.510713 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_41\">\n",
       "    <path d=\"M 964.664339 193.890733 \n",
       "C 967.461048 193.890733 970.143587 192.779588 972.121158 190.802017 \n",
       "C 974.09873 188.824445 975.209874 186.141906 975.209874 183.345198 \n",
       "C 975.209874 180.548489 974.09873 177.86595 972.121158 175.888378 \n",
       "C 970.143587 173.910807 967.461048 172.799663 964.664339 172.799663 \n",
       "C 961.86763 172.799663 959.185091 173.910807 957.20752 175.888378 \n",
       "C 955.229948 177.86595 954.118804 180.548489 954.118804 183.345198 \n",
       "C 954.118804 186.141906 955.229948 188.824445 957.20752 190.802017 \n",
       "C 959.185091 192.779588 961.86763 193.890733 964.664339 193.890733 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 2; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_42\">\n",
       "    <path d=\"M 995.953289 105.702249 \n",
       "L 1026.083388 105.702249 \n",
       "L 1026.083388 75.572149 \n",
       "L 995.953289 75.572149 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_43\">\n",
       "    <path d=\"M 995.081833 198.410247 \n",
       "L 1026.954843 198.410247 \n",
       "L 1026.954843 168.280148 \n",
       "L 995.081833 168.280148 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_44\">\n",
       "    <path d=\"M 1057.372338 95.156714 \n",
       "C 1058.570927 95.156714 1059.720587 94.680509 1060.568117 93.832979 \n",
       "C 1061.415648 92.985448 1061.891853 91.835788 1061.891853 90.637199 \n",
       "C 1061.891853 89.43861 1061.415648 88.28895 1060.568117 87.441419 \n",
       "C 1059.720587 86.593889 1058.570927 86.117684 1057.372338 86.117684 \n",
       "C 1056.173748 86.117684 1055.024089 86.593889 1054.176558 87.441419 \n",
       "C 1053.329027 88.28895 1052.852823 89.43861 1052.852823 90.637199 \n",
       "C 1052.852823 91.835788 1053.329027 92.985448 1054.176558 93.832979 \n",
       "C 1055.024089 94.680509 1056.173748 95.156714 1057.372338 95.156714 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_45\">\n",
       "    <path d=\"M 1057.372338 193.890733 \n",
       "C 1060.169046 193.890733 1062.851585 192.779588 1064.829157 190.802017 \n",
       "C 1066.806729 188.824445 1067.917873 186.141906 1067.917873 183.345198 \n",
       "C 1067.917873 180.548489 1066.806729 177.86595 1064.829157 175.888378 \n",
       "C 1062.851585 173.910807 1060.169046 172.799663 1057.372338 172.799663 \n",
       "C 1054.575629 172.799663 1051.89309 173.910807 1049.915519 175.888378 \n",
       "C 1047.937947 177.86595 1046.826803 180.548489 1046.826803 183.345198 \n",
       "C 1046.826803 186.141906 1047.937947 188.824445 1049.915519 190.802017 \n",
       "C 1051.89309 192.779588 1054.575629 193.890733 1057.372338 193.890733 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 2; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_46\">\n",
       "    <path d=\"M 1087.74116 198.410247 \n",
       "L 1119.711514 198.410247 \n",
       "L 1119.711514 168.280148 \n",
       "L 1087.74116 168.280148 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_47\">\n",
       "    <path d=\"M 1150.080337 141.510713 \n",
       "C 1151.278926 141.510713 1152.428585 141.034509 1153.276116 140.186978 \n",
       "C 1154.123647 139.339447 1154.599851 138.189788 1154.599851 136.991198 \n",
       "C 1154.599851 135.792609 1154.123647 134.642949 1153.276116 133.795419 \n",
       "C 1152.428585 132.947888 1151.278926 132.471683 1150.080337 132.471683 \n",
       "C 1148.881747 132.471683 1147.732088 132.947888 1146.884557 133.795419 \n",
       "C 1146.037026 134.642949 1145.560822 135.792609 1145.560822 136.991198 \n",
       "C 1145.560822 138.189788 1146.037026 139.339447 1146.884557 140.186978 \n",
       "C 1147.732088 141.034509 1148.881747 141.510713 1150.080337 141.510713 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_48\">\n",
       "    <path d=\"M 1150.080337 193.890733 \n",
       "C 1152.877045 193.890733 1155.559584 192.779588 1157.537156 190.802017 \n",
       "C 1159.514727 188.824445 1160.625871 186.141906 1160.625871 183.345198 \n",
       "C 1160.625871 180.548489 1159.514727 177.86595 1157.537156 175.888378 \n",
       "C 1155.559584 173.910807 1152.877045 172.799663 1150.080337 172.799663 \n",
       "C 1147.283628 172.799663 1144.601089 173.910807 1142.623517 175.888378 \n",
       "C 1140.645946 177.86595 1139.534802 180.548489 1139.534802 183.345198 \n",
       "C 1139.534802 186.141906 1140.645946 188.824445 1142.623517 190.802017 \n",
       "C 1144.601089 192.779588 1147.283628 193.890733 1150.080337 193.890733 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 2; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_49\">\n",
       "    <path d=\"M 1181.369286 198.410247 \n",
       "L 1211.499386 198.410247 \n",
       "L 1211.499386 168.280148 \n",
       "L 1181.369286 168.280148 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_50\">\n",
       "    <path d=\"M 1242.788335 95.156714 \n",
       "C 1243.986925 95.156714 1245.136584 94.680509 1245.984115 93.832979 \n",
       "C 1246.831646 92.985448 1247.30785 91.835788 1247.30785 90.637199 \n",
       "C 1247.30785 89.43861 1246.831646 88.28895 1245.984115 87.441419 \n",
       "C 1245.136584 86.593889 1243.986925 86.117684 1242.788335 86.117684 \n",
       "C 1241.589746 86.117684 1240.440086 86.593889 1239.592556 87.441419 \n",
       "C 1238.745025 88.28895 1238.26882 89.43861 1238.26882 90.637199 \n",
       "C 1238.26882 91.835788 1238.745025 92.985448 1239.592556 93.832979 \n",
       "C 1240.440086 94.680509 1241.589746 95.156714 1242.788335 95.156714 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_51\">\n",
       "    <path d=\"M 1242.788335 193.890733 \n",
       "C 1245.585044 193.890733 1248.267583 192.779588 1250.245154 190.802017 \n",
       "C 1252.222726 188.824445 1253.33387 186.141906 1253.33387 183.345198 \n",
       "C 1253.33387 180.548489 1252.222726 177.86595 1250.245154 175.888378 \n",
       "C 1248.267583 173.910807 1245.585044 172.799663 1242.788335 172.799663 \n",
       "C 1239.991627 172.799663 1237.309088 173.910807 1235.331516 175.888378 \n",
       "C 1233.353944 177.86595 1232.2428 180.548489 1232.2428 183.345198 \n",
       "C 1232.2428 186.141906 1233.353944 188.824445 1235.331516 190.802017 \n",
       "C 1237.309088 192.779588 1239.991627 193.890733 1242.788335 193.890733 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #1192e8; stroke: #1192e8; stroke-width: 2; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_52\">\n",
       "    <path d=\"M 115.2273 476.534244 \n",
       "L 145.3574 476.534244 \n",
       "L 145.3574 446.404144 \n",
       "L 115.2273 446.404144 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #6929c4; stroke: #6929c4; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_53\">\n",
       "    <path d=\"M 207.935299 337.472246 \n",
       "L 238.065399 337.472246 \n",
       "L 238.065399 307.342146 \n",
       "L 207.935299 307.342146 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #121619; stroke: #121619; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_54\">\n",
       "    <path d=\"M 233.545884 326.926711 \n",
       "C 233.545884 324.130934 232.434081 321.446804 230.457168 319.469892 \n",
       "C 228.480255 317.492979 225.796126 316.381176 223.000349 316.381176 \n",
       "C 220.204572 316.381176 217.520443 317.492979 215.54353 319.469892 \n",
       "C 213.566617 321.446804 212.454814 324.130934 212.454814 326.926711 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_35\">\n",
       "    <path d=\"M 223.000349 326.926711 \n",
       "L 233.545884 316.381176 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_55\">\n",
       "    <path d=\"M 254.289298 383.826245 \n",
       "L 284.419398 383.826245 \n",
       "L 284.419398 353.696145 \n",
       "L 254.289298 353.696145 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #121619; stroke: #121619; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_56\">\n",
       "    <path d=\"M 279.899883 373.28071 \n",
       "C 279.899883 370.484933 278.78808 367.800804 276.811167 365.823891 \n",
       "C 274.834254 363.846978 272.150125 362.735175 269.354348 362.735175 \n",
       "C 266.558571 362.735175 263.874442 363.846978 261.897529 365.823891 \n",
       "C 259.920616 367.800804 258.808813 370.484933 258.808813 373.28071 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_36\">\n",
       "    <path d=\"M 269.354348 373.28071 \n",
       "L 279.899883 362.735175 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_57\">\n",
       "    <path d=\"M 300.643298 430.180244 \n",
       "L 330.773397 430.180244 \n",
       "L 330.773397 400.050145 \n",
       "L 300.643298 400.050145 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #121619; stroke: #121619; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_58\">\n",
       "    <path d=\"M 326.253882 419.63471 \n",
       "C 326.253882 416.838932 325.14208 414.154803 323.165167 412.17789 \n",
       "C 321.188254 410.200977 318.504125 409.089175 315.708348 409.089175 \n",
       "C 312.912571 409.089175 310.228441 410.200977 308.251528 412.17789 \n",
       "C 306.274615 414.154803 305.162813 416.838932 305.162813 419.63471 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_37\">\n",
       "    <path d=\"M 315.708348 419.63471 \n",
       "L 326.253882 409.089175 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_59\">\n",
       "    <path d=\"M 346.997297 476.534244 \n",
       "L 377.127397 476.534244 \n",
       "L 377.127397 446.404144 \n",
       "L 346.997297 446.404144 \n",
       "z\n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: #121619; stroke: #121619; stroke-width: 1.5; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_60\">\n",
       "    <path d=\"M 372.607882 465.988709 \n",
       "C 372.607882 463.192932 371.496079 460.508803 369.519166 458.53189 \n",
       "C 367.542253 456.554977 364.858124 455.443174 362.062347 455.443174 \n",
       "C 359.26657 455.443174 356.582441 456.554977 354.605528 458.53189 \n",
       "C 352.628615 460.508803 351.516812 463.192932 351.516812 465.988709 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linejoin: miter\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_38\">\n",
       "    <path d=\"M 362.062347 465.988709 \n",
       "L 372.607882 455.443174 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"text_1\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- ${q7183}_{0}$ -->\n",
       "     <g transform=\"translate(36.352891 48.734176)scale(0.1625 -0.1625)\">\n",
       "      <defs>\n",
       "       <path id=\"DejaVuSans-Oblique-71\" d=\"M 2669 525 \n",
       "Q 2438 222 2123 65 \n",
       "Q 1809 -91 1428 -91 \n",
       "Q 897 -91 595 267 \n",
       "Q 294 625 294 1253 \n",
       "Q 294 1759 480 2231 \n",
       "Q 666 2703 1013 3078 \n",
       "Q 1238 3322 1530 3453 \n",
       "Q 1822 3584 2144 3584 \n",
       "Q 2531 3584 2781 3431 \n",
       "Q 3031 3278 3144 2969 \n",
       "L 3244 3494 \n",
       "L 3822 3494 \n",
       "L 2888 -1319 \n",
       "L 2309 -1319 \n",
       "L 2669 525 \n",
       "z\n",
       "M 891 1338 \n",
       "Q 891 875 1084 633 \n",
       "Q 1278 391 1644 391 \n",
       "Q 2188 391 2572 911 \n",
       "Q 2956 1431 2956 2175 \n",
       "Q 2956 2625 2757 2864 \n",
       "Q 2559 3103 2188 3103 \n",
       "Q 1916 3103 1684 2976 \n",
       "Q 1453 2850 1281 2606 \n",
       "Q 1100 2350 995 2006 \n",
       "Q 891 1663 891 1338 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       <path id=\"DejaVuSans-37\" d=\"M 525 4666 \n",
       "L 3525 4666 \n",
       "L 3525 4397 \n",
       "L 1831 0 \n",
       "L 1172 0 \n",
       "L 2766 4134 \n",
       "L 525 4134 \n",
       "L 525 4666 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       <path id=\"DejaVuSans-31\" d=\"M 794 531 \n",
       "L 1825 531 \n",
       "L 1825 4091 \n",
       "L 703 3866 \n",
       "L 703 4441 \n",
       "L 1819 4666 \n",
       "L 2450 4666 \n",
       "L 2450 531 \n",
       "L 3481 531 \n",
       "L 3481 0 \n",
       "L 794 0 \n",
       "L 794 531 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       <path id=\"DejaVuSans-38\" d=\"M 2034 2216 \n",
       "Q 1584 2216 1326 1975 \n",
       "Q 1069 1734 1069 1313 \n",
       "Q 1069 891 1326 650 \n",
       "Q 1584 409 2034 409 \n",
       "Q 2484 409 2743 651 \n",
       "Q 3003 894 3003 1313 \n",
       "Q 3003 1734 2745 1975 \n",
       "Q 2488 2216 2034 2216 \n",
       "z\n",
       "M 1403 2484 \n",
       "Q 997 2584 770 2862 \n",
       "Q 544 3141 544 3541 \n",
       "Q 544 4100 942 4425 \n",
       "Q 1341 4750 2034 4750 \n",
       "Q 2731 4750 3128 4425 \n",
       "Q 3525 4100 3525 3541 \n",
       "Q 3525 3141 3298 2862 \n",
       "Q 3072 2584 2669 2484 \n",
       "Q 3125 2378 3379 2068 \n",
       "Q 3634 1759 3634 1313 \n",
       "Q 3634 634 3220 271 \n",
       "Q 2806 -91 2034 -91 \n",
       "Q 1263 -91 848 271 \n",
       "Q 434 634 434 1313 \n",
       "Q 434 1759 690 2068 \n",
       "Q 947 2378 1403 2484 \n",
       "z\n",
       "M 1172 3481 \n",
       "Q 1172 3119 1398 2916 \n",
       "Q 1625 2713 2034 2713 \n",
       "Q 2441 2713 2670 2916 \n",
       "Q 2900 3119 2900 3481 \n",
       "Q 2900 3844 2670 4047 \n",
       "Q 2441 4250 2034 4250 \n",
       "Q 1625 4250 1398 4047 \n",
       "Q 1172 3844 1172 3481 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       <path id=\"DejaVuSans-33\" d=\"M 2597 2516 \n",
       "Q 3050 2419 3304 2112 \n",
       "Q 3559 1806 3559 1356 \n",
       "Q 3559 666 3084 287 \n",
       "Q 2609 -91 1734 -91 \n",
       "Q 1441 -91 1130 -33 \n",
       "Q 819 25 488 141 \n",
       "L 488 750 \n",
       "Q 750 597 1062 519 \n",
       "Q 1375 441 1716 441 \n",
       "Q 2309 441 2620 675 \n",
       "Q 2931 909 2931 1356 \n",
       "Q 2931 1769 2642 2001 \n",
       "Q 2353 2234 1838 2234 \n",
       "L 1294 2234 \n",
       "L 1294 2753 \n",
       "L 1863 2753 \n",
       "Q 2328 2753 2575 2939 \n",
       "Q 2822 3125 2822 3475 \n",
       "Q 2822 3834 2567 4026 \n",
       "Q 2313 4219 1838 4219 \n",
       "Q 1578 4219 1281 4162 \n",
       "Q 984 4106 628 3988 \n",
       "L 628 4550 \n",
       "Q 988 4650 1302 4700 \n",
       "Q 1616 4750 1894 4750 \n",
       "Q 2613 4750 3031 4423 \n",
       "Q 3450 4097 3450 3541 \n",
       "Q 3450 3153 3228 2886 \n",
       "Q 3006 2619 2597 2516 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       <path id=\"DejaVuSans-30\" d=\"M 2034 4250 \n",
       "Q 1547 4250 1301 3770 \n",
       "Q 1056 3291 1056 2328 \n",
       "Q 1056 1369 1301 889 \n",
       "Q 1547 409 2034 409 \n",
       "Q 2525 409 2770 889 \n",
       "Q 3016 1369 3016 2328 \n",
       "Q 3016 3291 2770 3770 \n",
       "Q 2525 4250 2034 4250 \n",
       "z\n",
       "M 2034 4750 \n",
       "Q 2819 4750 3233 4129 \n",
       "Q 3647 3509 3647 2328 \n",
       "Q 3647 1150 3233 529 \n",
       "Q 2819 -91 2034 -91 \n",
       "Q 1250 -91 836 529 \n",
       "Q 422 1150 422 2328 \n",
       "Q 422 3509 836 4129 \n",
       "Q 1250 4750 2034 4750 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      </defs>\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-71\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-37\" transform=\"translate(63.476562 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-31\" transform=\"translate(127.099609 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-38\" transform=\"translate(190.722656 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-33\" transform=\"translate(254.345703 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-30\" transform=\"translate(318.925781 -15.625)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_2\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- ${q7183}_{1}$ -->\n",
       "     <g transform=\"translate(36.352891 95.088175)scale(0.1625 -0.1625)\">\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-71\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-37\" transform=\"translate(63.476562 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-31\" transform=\"translate(127.099609 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-38\" transform=\"translate(190.722656 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-33\" transform=\"translate(254.345703 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-31\" transform=\"translate(318.925781 -15.625)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_3\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- ${q7183}_{2}$ -->\n",
       "     <g transform=\"translate(36.352891 141.442175)scale(0.1625 -0.1625)\">\n",
       "      <defs>\n",
       "       <path id=\"DejaVuSans-32\" d=\"M 1228 531 \n",
       "L 3431 531 \n",
       "L 3431 0 \n",
       "L 469 0 \n",
       "L 469 531 \n",
       "Q 828 903 1448 1529 \n",
       "Q 2069 2156 2228 2338 \n",
       "Q 2531 2678 2651 2914 \n",
       "Q 2772 3150 2772 3378 \n",
       "Q 2772 3750 2511 3984 \n",
       "Q 2250 4219 1831 4219 \n",
       "Q 1534 4219 1204 4116 \n",
       "Q 875 4013 500 3803 \n",
       "L 500 4441 \n",
       "Q 881 4594 1212 4672 \n",
       "Q 1544 4750 1819 4750 \n",
       "Q 2544 4750 2975 4387 \n",
       "Q 3406 4025 3406 3419 \n",
       "Q 3406 3131 3298 2873 \n",
       "Q 3191 2616 2906 2266 \n",
       "Q 2828 2175 2409 1742 \n",
       "Q 1991 1309 1228 531 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      </defs>\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-71\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-37\" transform=\"translate(63.476562 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-31\" transform=\"translate(127.099609 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-38\" transform=\"translate(190.722656 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-33\" transform=\"translate(254.345703 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-32\" transform=\"translate(318.925781 -15.625)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_4\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- ${q7183}_{3}$ -->\n",
       "     <g transform=\"translate(36.352891 187.796174)scale(0.1625 -0.1625)\">\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-71\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-37\" transform=\"translate(63.476562 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-31\" transform=\"translate(127.099609 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-38\" transform=\"translate(190.722656 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-33\" transform=\"translate(254.345703 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-33\" transform=\"translate(318.925781 -15.625)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_5\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- 4 -->\n",
       "     <g transform=\"translate(109.89659 222.900922)scale(0.104 -0.104)\">\n",
       "      <defs>\n",
       "       <path id=\"DejaVuSans-34\" d=\"M 2419 4116 \n",
       "L 825 1625 \n",
       "L 2419 1625 \n",
       "L 2419 4116 \n",
       "z\n",
       "M 2253 4666 \n",
       "L 3047 4666 \n",
       "L 3047 1625 \n",
       "L 3713 1625 \n",
       "L 3713 1100 \n",
       "L 3047 1100 \n",
       "L 3047 0 \n",
       "L 2419 0 \n",
       "L 2419 1100 \n",
       "L 313 1100 \n",
       "L 313 1709 \n",
       "L 2253 4666 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      </defs>\n",
       "      <use xlink:href=\"#DejaVuSans-34\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_6\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- meas -->\n",
       "     <g transform=\"translate(51.739609 234.183181)scale(0.1625 -0.1625)\">\n",
       "      <defs>\n",
       "       <path id=\"DejaVuSans-6d\" d=\"M 3328 2828 \n",
       "Q 3544 3216 3844 3400 \n",
       "Q 4144 3584 4550 3584 \n",
       "Q 5097 3584 5394 3201 \n",
       "Q 5691 2819 5691 2113 \n",
       "L 5691 0 \n",
       "L 5113 0 \n",
       "L 5113 2094 \n",
       "Q 5113 2597 4934 2840 \n",
       "Q 4756 3084 4391 3084 \n",
       "Q 3944 3084 3684 2787 \n",
       "Q 3425 2491 3425 1978 \n",
       "L 3425 0 \n",
       "L 2847 0 \n",
       "L 2847 2094 \n",
       "Q 2847 2600 2669 2842 \n",
       "Q 2491 3084 2119 3084 \n",
       "Q 1678 3084 1418 2786 \n",
       "Q 1159 2488 1159 1978 \n",
       "L 1159 0 \n",
       "L 581 0 \n",
       "L 581 3500 \n",
       "L 1159 3500 \n",
       "L 1159 2956 \n",
       "Q 1356 3278 1631 3431 \n",
       "Q 1906 3584 2284 3584 \n",
       "Q 2666 3584 2933 3390 \n",
       "Q 3200 3197 3328 2828 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       <path id=\"DejaVuSans-65\" d=\"M 3597 1894 \n",
       "L 3597 1613 \n",
       "L 953 1613 \n",
       "Q 991 1019 1311 708 \n",
       "Q 1631 397 2203 397 \n",
       "Q 2534 397 2845 478 \n",
       "Q 3156 559 3463 722 \n",
       "L 3463 178 \n",
       "Q 3153 47 2828 -22 \n",
       "Q 2503 -91 2169 -91 \n",
       "Q 1331 -91 842 396 \n",
       "Q 353 884 353 1716 \n",
       "Q 353 2575 817 3079 \n",
       "Q 1281 3584 2069 3584 \n",
       "Q 2775 3584 3186 3129 \n",
       "Q 3597 2675 3597 1894 \n",
       "z\n",
       "M 3022 2063 \n",
       "Q 3016 2534 2758 2815 \n",
       "Q 2500 3097 2075 3097 \n",
       "Q 1594 3097 1305 2825 \n",
       "Q 1016 2553 972 2059 \n",
       "L 3022 2063 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       <path id=\"DejaVuSans-61\" d=\"M 2194 1759 \n",
       "Q 1497 1759 1228 1600 \n",
       "Q 959 1441 959 1056 \n",
       "Q 959 750 1161 570 \n",
       "Q 1363 391 1709 391 \n",
       "Q 2188 391 2477 730 \n",
       "Q 2766 1069 2766 1631 \n",
       "L 2766 1759 \n",
       "L 2194 1759 \n",
       "z\n",
       "M 3341 1997 \n",
       "L 3341 0 \n",
       "L 2766 0 \n",
       "L 2766 531 \n",
       "Q 2569 213 2275 61 \n",
       "Q 1981 -91 1556 -91 \n",
       "Q 1019 -91 701 211 \n",
       "Q 384 513 384 1019 \n",
       "Q 384 1609 779 1909 \n",
       "Q 1175 2209 1959 2209 \n",
       "L 2766 2209 \n",
       "L 2766 2266 \n",
       "Q 2766 2663 2505 2880 \n",
       "Q 2244 3097 1772 3097 \n",
       "Q 1472 3097 1187 3025 \n",
       "Q 903 2953 641 2809 \n",
       "L 641 3341 \n",
       "Q 956 3463 1253 3523 \n",
       "Q 1550 3584 1831 3584 \n",
       "Q 2591 3584 2966 3190 \n",
       "Q 3341 2797 3341 1997 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       <path id=\"DejaVuSans-73\" d=\"M 2834 3397 \n",
       "L 2834 2853 \n",
       "Q 2591 2978 2328 3040 \n",
       "Q 2066 3103 1784 3103 \n",
       "Q 1356 3103 1142 2972 \n",
       "Q 928 2841 928 2578 \n",
       "Q 928 2378 1081 2264 \n",
       "Q 1234 2150 1697 2047 \n",
       "L 1894 2003 \n",
       "Q 2506 1872 2764 1633 \n",
       "Q 3022 1394 3022 966 \n",
       "Q 3022 478 2636 193 \n",
       "Q 2250 -91 1575 -91 \n",
       "Q 1294 -91 989 -36 \n",
       "Q 684 19 347 128 \n",
       "L 347 722 \n",
       "Q 666 556 975 473 \n",
       "Q 1284 391 1588 391 \n",
       "Q 1994 391 2212 530 \n",
       "Q 2431 669 2431 922 \n",
       "Q 2431 1156 2273 1281 \n",
       "Q 2116 1406 1581 1522 \n",
       "L 1381 1569 \n",
       "Q 847 1681 609 1914 \n",
       "Q 372 2147 372 2553 \n",
       "Q 372 3047 722 3315 \n",
       "Q 1072 3584 1716 3584 \n",
       "Q 2034 3584 2315 3537 \n",
       "Q 2597 3491 2834 3397 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      </defs>\n",
       "      <use xlink:href=\"#DejaVuSans-6d\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-65\" x=\"97.412109\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-61\" x=\"158.935547\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-73\" x=\"220.214844\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_7\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- ${q7183}_{0}$ -->\n",
       "     <g transform=\"translate(36.352891 326.858172)scale(0.1625 -0.1625)\">\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-71\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-37\" transform=\"translate(63.476562 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-31\" transform=\"translate(127.099609 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-38\" transform=\"translate(190.722656 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-33\" transform=\"translate(254.345703 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-30\" transform=\"translate(318.925781 -15.625)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_8\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- ${q7183}_{1}$ -->\n",
       "     <g transform=\"translate(36.352891 373.212172)scale(0.1625 -0.1625)\">\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-71\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-37\" transform=\"translate(63.476562 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-31\" transform=\"translate(127.099609 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-38\" transform=\"translate(190.722656 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-33\" transform=\"translate(254.345703 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-31\" transform=\"translate(318.925781 -15.625)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_9\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- ${q7183}_{2}$ -->\n",
       "     <g transform=\"translate(36.352891 419.566171)scale(0.1625 -0.1625)\">\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-71\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-37\" transform=\"translate(63.476562 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-31\" transform=\"translate(127.099609 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-38\" transform=\"translate(190.722656 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-33\" transform=\"translate(254.345703 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-32\" transform=\"translate(318.925781 -15.625)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_10\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- ${q7183}_{3}$ -->\n",
       "     <g transform=\"translate(36.352891 465.920171)scale(0.1625 -0.1625)\">\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-71\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-37\" transform=\"translate(63.476562 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-31\" transform=\"translate(127.099609 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-38\" transform=\"translate(190.722656 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-33\" transform=\"translate(254.345703 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-33\" transform=\"translate(318.925781 -15.625)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_11\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- 4 -->\n",
       "     <g transform=\"translate(109.89659 501.024918)scale(0.104 -0.104)\">\n",
       "      <use xlink:href=\"#DejaVuSans-34\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_12\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- meas -->\n",
       "     <g transform=\"translate(51.739609 512.307178)scale(0.1625 -0.1625)\">\n",
       "      <use xlink:href=\"#DejaVuSans-6d\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-65\" x=\"97.412109\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-61\" x=\"158.935547\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-73\" x=\"220.214844\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_13\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- 0 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(127.74735 55.529729)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-30\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_14\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $\\mathrm{R_Y}$ -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(122.75235 43.350872)scale(0.13 -0.13)\">\n",
       "      <defs>\n",
       "       <path id=\"DejaVuSans-52\" d=\"M 2841 2188 \n",
       "Q 3044 2119 3236 1894 \n",
       "Q 3428 1669 3622 1275 \n",
       "L 4263 0 \n",
       "L 3584 0 \n",
       "L 2988 1197 \n",
       "Q 2756 1666 2539 1819 \n",
       "Q 2322 1972 1947 1972 \n",
       "L 1259 1972 \n",
       "L 1259 0 \n",
       "L 628 0 \n",
       "L 628 4666 \n",
       "L 2053 4666 \n",
       "Q 2853 4666 3247 4331 \n",
       "Q 3641 3997 3641 3322 \n",
       "Q 3641 2881 3436 2590 \n",
       "Q 3231 2300 2841 2188 \n",
       "z\n",
       "M 1259 4147 \n",
       "L 1259 2491 \n",
       "L 2053 2491 \n",
       "Q 2509 2491 2742 2702 \n",
       "Q 2975 2913 2975 3322 \n",
       "Q 2975 3731 2742 3939 \n",
       "Q 2509 4147 2053 4147 \n",
       "L 1259 4147 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       <path id=\"DejaVuSans-59\" d=\"M -13 4666 \n",
       "L 666 4666 \n",
       "L 1959 2747 \n",
       "L 3244 4666 \n",
       "L 3922 4666 \n",
       "L 2272 2222 \n",
       "L 2272 0 \n",
       "L 1638 0 \n",
       "L 1638 2222 \n",
       "L -13 4666 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      </defs>\n",
       "      <use xlink:href=\"#DejaVuSans-52\" transform=\"translate(0 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-59\" transform=\"translate(70.439453 -16.3125)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_15\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- H -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(125.404147 94.224386)scale(0.13 -0.13)\">\n",
       "      <defs>\n",
       "       <path id=\"DejaVuSans-48\" d=\"M 628 4666 \n",
       "L 1259 4666 \n",
       "L 1259 2753 \n",
       "L 3553 2753 \n",
       "L 3553 4666 \n",
       "L 4184 4666 \n",
       "L 4184 0 \n",
       "L 3553 0 \n",
       "L 3553 2222 \n",
       "L 1259 2222 \n",
       "L 1259 0 \n",
       "L 628 0 \n",
       "L 628 4666 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      </defs>\n",
       "      <use xlink:href=\"#DejaVuSans-48\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_16\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- H -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(125.404147 140.578386)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-48\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_17\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- 2 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(197.278349 101.883729)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-32\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_18\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- P -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(195.904052 89.704871)scale(0.13 -0.13)\">\n",
       "      <defs>\n",
       "       <path id=\"DejaVuSans-50\" d=\"M 1259 4147 \n",
       "L 1259 2394 \n",
       "L 2053 2394 \n",
       "Q 2494 2394 2734 2622 \n",
       "Q 2975 2850 2975 3272 \n",
       "Q 2975 3691 2734 3919 \n",
       "Q 2494 4147 2053 4147 \n",
       "L 1259 4147 \n",
       "z\n",
       "M 628 4666 \n",
       "L 2053 4666 \n",
       "Q 2838 4666 3239 4311 \n",
       "Q 3641 3956 3641 3272 \n",
       "Q 3641 2581 3239 2228 \n",
       "Q 2838 1875 2053 1875 \n",
       "L 1259 1875 \n",
       "L 1259 0 \n",
       "L 628 0 \n",
       "L 628 4666 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      </defs>\n",
       "      <use xlink:href=\"#DejaVuSans-50\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_19\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- 4 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(197.278349 148.237728)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-34\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_20\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- P -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(195.904052 136.058871)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-50\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_21\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $-$0.667, $-$$\\pi$/2, $\\pi$/2 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(164.263349 55.529729)scale(0.08 -0.08)\">\n",
       "      <defs>\n",
       "       <path id=\"DejaVuSans-2212\" d=\"M 678 2272 \n",
       "L 4684 2272 \n",
       "L 4684 1741 \n",
       "L 678 1741 \n",
       "L 678 2272 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       <path id=\"DejaVuSans-2e\" d=\"M 684 794 \n",
       "L 1344 794 \n",
       "L 1344 0 \n",
       "L 684 0 \n",
       "L 684 794 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       <path id=\"DejaVuSans-36\" d=\"M 2113 2584 \n",
       "Q 1688 2584 1439 2293 \n",
       "Q 1191 2003 1191 1497 \n",
       "Q 1191 994 1439 701 \n",
       "Q 1688 409 2113 409 \n",
       "Q 2538 409 2786 701 \n",
       "Q 3034 994 3034 1497 \n",
       "Q 3034 2003 2786 2293 \n",
       "Q 2538 2584 2113 2584 \n",
       "z\n",
       "M 3366 4563 \n",
       "L 3366 3988 \n",
       "Q 3128 4100 2886 4159 \n",
       "Q 2644 4219 2406 4219 \n",
       "Q 1781 4219 1451 3797 \n",
       "Q 1122 3375 1075 2522 \n",
       "Q 1259 2794 1537 2939 \n",
       "Q 1816 3084 2150 3084 \n",
       "Q 2853 3084 3261 2657 \n",
       "Q 3669 2231 3669 1497 \n",
       "Q 3669 778 3244 343 \n",
       "Q 2819 -91 2113 -91 \n",
       "Q 1303 -91 875 529 \n",
       "Q 447 1150 447 2328 \n",
       "Q 447 3434 972 4092 \n",
       "Q 1497 4750 2381 4750 \n",
       "Q 2619 4750 2861 4703 \n",
       "Q 3103 4656 3366 4563 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       <path id=\"DejaVuSans-2c\" d=\"M 750 794 \n",
       "L 1409 794 \n",
       "L 1409 256 \n",
       "L 897 -744 \n",
       "L 494 -744 \n",
       "L 750 256 \n",
       "L 750 794 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       <path id=\"DejaVuSans-20\" transform=\"scale(0.015625)\"/>\n",
       "       <path id=\"DejaVuSans-Oblique-3c0\" d=\"M 584 3500 \n",
       "L 3938 3500 \n",
       "L 3825 2925 \n",
       "L 3384 2925 \n",
       "L 2966 775 \n",
       "Q 2922 550 2981 450 \n",
       "Q 3038 353 3209 353 \n",
       "Q 3256 353 3325 363 \n",
       "Q 3397 369 3419 372 \n",
       "L 3338 -44 \n",
       "Q 3222 -84 3103 -103 \n",
       "Q 2981 -122 2866 -122 \n",
       "Q 2491 -122 2388 81 \n",
       "Q 2284 288 2391 838 \n",
       "L 2797 2925 \n",
       "L 1506 2925 \n",
       "L 938 0 \n",
       "L 350 0 \n",
       "L 919 2925 \n",
       "L 472 2925 \n",
       "L 584 3500 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       <path id=\"DejaVuSans-2f\" d=\"M 1625 4666 \n",
       "L 2156 4666 \n",
       "L 531 -594 \n",
       "L 0 -594 \n",
       "L 1625 4666 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      </defs>\n",
       "      <use xlink:href=\"#DejaVuSans-2212\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-30\" transform=\"translate(83.789062 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2e\" transform=\"translate(147.412109 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-36\" transform=\"translate(179.199219 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-36\" transform=\"translate(242.822266 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-37\" transform=\"translate(306.445312 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2c\" transform=\"translate(370.068359 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-20\" transform=\"translate(401.855469 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2212\" transform=\"translate(433.642578 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-3c0\" transform=\"translate(517.431641 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2f\" transform=\"translate(577.636719 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-32\" transform=\"translate(607.703125 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2c\" transform=\"translate(671.326172 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-20\" transform=\"translate(703.113281 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-3c0\" transform=\"translate(734.900391 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2f\" transform=\"translate(795.105469 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-32\" transform=\"translate(825.171875 0.78125)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_22\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- U -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(195.066162 43.350872)scale(0.13 -0.13)\">\n",
       "      <defs>\n",
       "       <path id=\"DejaVuSans-55\" d=\"M 556 4666 \n",
       "L 1191 4666 \n",
       "L 1191 1831 \n",
       "Q 1191 1081 1462 751 \n",
       "Q 1734 422 2344 422 \n",
       "Q 2950 422 3222 751 \n",
       "Q 3494 1081 3494 1831 \n",
       "L 3494 4666 \n",
       "L 4128 4666 \n",
       "L 4128 1753 \n",
       "Q 4128 841 3676 375 \n",
       "Q 3225 -91 2344 -91 \n",
       "Q 1459 -91 1007 375 \n",
       "Q 556 841 556 1753 \n",
       "L 556 4666 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      </defs>\n",
       "      <use xlink:href=\"#DejaVuSans-55\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_23\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $\\pi$/2 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(263.194348 55.529729)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-3c0\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2f\" transform=\"translate(60.205078 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-32\" transform=\"translate(90.271484 0.78125)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_24\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- P -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(265.435051 43.350872)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-50\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"line2d_39\">\n",
       "    <path d=\"M 315.708348 50.309219 \n",
       "L 315.708348 38.25718 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_40\">\n",
       "    <path d=\"M 309.682328 44.2832 \n",
       "L 321.734368 44.2832 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"text_25\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $-$0.667 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(347.222347 55.529729)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-2212\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-30\" transform=\"translate(83.789062 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2e\" transform=\"translate(147.412109 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-36\" transform=\"translate(179.199219 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-36\" transform=\"translate(242.822266 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-37\" transform=\"translate(306.445312 0.78125)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_26\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $\\mathrm{R_Y}$ -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(354.522347 43.350872)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-52\" transform=\"translate(0 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-59\" transform=\"translate(70.439453 -16.3125)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"line2d_41\">\n",
       "    <path d=\"M 408.416346 50.309219 \n",
       "L 408.416346 38.25718 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_42\">\n",
       "    <path d=\"M 402.390326 44.2832 \n",
       "L 414.442366 44.2832 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"text_27\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- 0.667 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(443.319096 55.529729)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-30\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-36\" x=\"95.410156\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-36\" x=\"159.033203\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-37\" x=\"222.65625\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_28\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $\\mathrm{R_Y}$ -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(447.230346 43.350872)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-52\" transform=\"translate(0 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-59\" transform=\"translate(70.439453 -16.3125)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_29\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- 3$\\pi$/2 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(492.404345 55.529729)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-33\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-3c0\" transform=\"translate(63.623047 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2f\" transform=\"translate(123.828125 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-32\" transform=\"translate(153.894531 0.78125)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_30\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- P -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(497.205048 43.350872)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-50\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_31\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $\\pi$/2 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(541.318345 55.529729)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-3c0\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2f\" transform=\"translate(60.205078 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-32\" transform=\"translate(90.271484 0.78125)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_32\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- P -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(543.559048 43.350872)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-50\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"line2d_43\">\n",
       "    <path d=\"M 593.832344 50.309219 \n",
       "L 593.832344 38.25718 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_44\">\n",
       "    <path d=\"M 587.806324 44.2832 \n",
       "L 599.858364 44.2832 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"text_33\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $-$1.33 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(627.906343 55.529729)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-2212\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-31\" transform=\"translate(83.789062 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2e\" transform=\"translate(147.412109 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-33\" transform=\"translate(179.199219 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-33\" transform=\"translate(242.822266 0.78125)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_34\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $\\mathrm{R_Y}$ -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(632.646343 43.350872)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-52\" transform=\"translate(0 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-59\" transform=\"translate(70.439453 -16.3125)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"line2d_45\">\n",
       "    <path d=\"M 686.540343 50.309219 \n",
       "L 686.540343 38.25718 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_46\">\n",
       "    <path d=\"M 680.514323 44.2832 \n",
       "L 692.566363 44.2832 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"text_35\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- 1.33 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(723.988092 55.529729)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-31\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-33\" x=\"95.410156\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-33\" x=\"159.033203\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_36\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $\\mathrm{R_Y}$ -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(725.354342 43.350872)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-52\" transform=\"translate(0 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-59\" transform=\"translate(70.439453 -16.3125)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_37\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- H -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(728.006139 140.578386)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-48\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_38\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- 3$\\pi$/2 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(770.528341 55.529729)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-33\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-3c0\" transform=\"translate(63.623047 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2f\" transform=\"translate(123.828125 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-32\" transform=\"translate(153.894531 0.78125)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_39\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- P -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(775.329045 43.350872)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-50\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_40\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $-$$\\pi$/4 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(769.568341 148.237728)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-2212\" transform=\"translate(0 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-3c0\" transform=\"translate(83.789062 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2f\" transform=\"translate(143.994141 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-34\" transform=\"translate(177.685547 0.09375)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_41\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $\\mathrm{R_Z}$ -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(771.318341 136.058871)scale(0.13 -0.13)\">\n",
       "      <defs>\n",
       "       <path id=\"DejaVuSans-5a\" d=\"M 359 4666 \n",
       "L 4025 4666 \n",
       "L 4025 4184 \n",
       "L 1075 531 \n",
       "L 4097 531 \n",
       "L 4097 0 \n",
       "L 288 0 \n",
       "L 288 481 \n",
       "L 3238 4134 \n",
       "L 359 4134 \n",
       "L 359 4666 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      </defs>\n",
       "      <use xlink:href=\"#DejaVuSans-52\" transform=\"translate(0 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-5a\" transform=\"translate(70.439453 -16.3125)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"line2d_47\">\n",
       "    <path d=\"M 825.602341 143.017218 \n",
       "L 825.602341 130.965178 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_48\">\n",
       "    <path d=\"M 819.576321 136.991198 \n",
       "L 831.628361 136.991198 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"text_42\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $\\pi$/4 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(865.63634 148.237728)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-3c0\" transform=\"translate(0 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2f\" transform=\"translate(60.205078 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-34\" transform=\"translate(93.896484 0.09375)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_43\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $\\mathrm{R_Z}$ -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(864.02634 136.058871)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-52\" transform=\"translate(0 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-5a\" transform=\"translate(70.439453 -16.3125)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"line2d_49\">\n",
       "    <path d=\"M 918.31034 143.017218 \n",
       "L 918.31034 130.965178 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_50\">\n",
       "    <path d=\"M 912.28432 136.991198 \n",
       "L 924.33636 136.991198 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"text_44\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $-$$\\pi$/4 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(954.984339 101.883729)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-2212\" transform=\"translate(0 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-Oblique-3c0\" transform=\"translate(83.789062 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2f\" transform=\"translate(143.994141 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-34\" transform=\"translate(177.685547 0.09375)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_45\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $\\mathrm{R_Z}$ -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(956.734339 89.704871)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-52\" transform=\"translate(0 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-5a\" transform=\"translate(70.439453 -16.3125)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"line2d_51\">\n",
       "    <path d=\"M 964.664339 189.371218 \n",
       "L 964.664339 177.319178 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_52\">\n",
       "    <path d=\"M 958.638319 183.345198 \n",
       "L 970.690359 183.345198 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"text_46\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- H -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(1006.130135 94.224386)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-48\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_47\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $-$0.694 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(996.178338 194.591728)scale(0.08 -0.08)\">\n",
       "      <defs>\n",
       "       <path id=\"DejaVuSans-39\" d=\"M 703 97 \n",
       "L 703 672 \n",
       "Q 941 559 1184 500 \n",
       "Q 1428 441 1663 441 \n",
       "Q 2288 441 2617 861 \n",
       "Q 2947 1281 2994 2138 \n",
       "Q 2813 1869 2534 1725 \n",
       "Q 2256 1581 1919 1581 \n",
       "Q 1219 1581 811 2004 \n",
       "Q 403 2428 403 3163 \n",
       "Q 403 3881 828 4315 \n",
       "Q 1253 4750 1959 4750 \n",
       "Q 2769 4750 3195 4129 \n",
       "Q 3622 3509 3622 2328 \n",
       "Q 3622 1225 3098 567 \n",
       "Q 2575 -91 1691 -91 \n",
       "Q 1453 -91 1209 -44 \n",
       "Q 966 3 703 97 \n",
       "z\n",
       "M 1959 2075 \n",
       "Q 2384 2075 2632 2365 \n",
       "Q 2881 2656 2881 3163 \n",
       "Q 2881 3666 2632 3958 \n",
       "Q 2384 4250 1959 4250 \n",
       "Q 1534 4250 1286 3958 \n",
       "Q 1038 3666 1038 3163 \n",
       "Q 1038 2656 1286 2365 \n",
       "Q 1534 2075 1959 2075 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      </defs>\n",
       "      <use xlink:href=\"#DejaVuSans-2212\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-30\" transform=\"translate(83.789062 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2e\" transform=\"translate(147.412109 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-36\" transform=\"translate(179.199219 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-39\" transform=\"translate(242.822266 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-34\" transform=\"translate(306.445312 0.78125)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_48\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $\\mathrm{R_Y}$ -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(1003.478338 182.41287)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-52\" transform=\"translate(0 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-59\" transform=\"translate(70.439453 -16.3125)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"line2d_53\">\n",
       "    <path d=\"M 1057.372338 189.371218 \n",
       "L 1057.372338 177.319178 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_54\">\n",
       "    <path d=\"M 1051.346318 183.345198 \n",
       "L 1063.398358 183.345198 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"text_49\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $-$0.877 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(1089.086337 194.591728)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-2212\" transform=\"translate(0 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-30\" transform=\"translate(83.789062 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2e\" transform=\"translate(147.412109 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-38\" transform=\"translate(176.574219 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-37\" transform=\"translate(240.197266 0.78125)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-37\" transform=\"translate(302.070312 0.78125)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_50\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $\\mathrm{R_Y}$ -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(1096.186337 182.41287)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-52\" transform=\"translate(0 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-59\" transform=\"translate(70.439453 -16.3125)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"line2d_55\">\n",
       "    <path d=\"M 1150.080337 189.371218 \n",
       "L 1150.080337 177.319178 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_56\">\n",
       "    <path d=\"M 1144.054317 183.345198 \n",
       "L 1156.106356 183.345198 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"text_51\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- 0.354 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(1184.983086 194.591728)scale(0.08 -0.08)\">\n",
       "      <defs>\n",
       "       <path id=\"DejaVuSans-35\" d=\"M 691 4666 \n",
       "L 3169 4666 \n",
       "L 3169 4134 \n",
       "L 1269 4134 \n",
       "L 1269 2991 \n",
       "Q 1406 3038 1543 3061 \n",
       "Q 1681 3084 1819 3084 \n",
       "Q 2600 3084 3056 2656 \n",
       "Q 3513 2228 3513 1497 \n",
       "Q 3513 744 3044 326 \n",
       "Q 2575 -91 1722 -91 \n",
       "Q 1428 -91 1123 -41 \n",
       "Q 819 9 494 109 \n",
       "L 494 744 \n",
       "Q 775 591 1075 516 \n",
       "Q 1375 441 1709 441 \n",
       "Q 2250 441 2565 725 \n",
       "Q 2881 1009 2881 1497 \n",
       "Q 2881 1984 2565 2268 \n",
       "Q 2250 2553 1709 2553 \n",
       "Q 1456 2553 1204 2497 \n",
       "Q 953 2441 691 2322 \n",
       "L 691 4666 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      </defs>\n",
       "      <use xlink:href=\"#DejaVuSans-30\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-33\" x=\"95.410156\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-35\" x=\"159.033203\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-34\" x=\"222.65625\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_52\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $\\mathrm{R_Y}$ -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(1188.894336 182.41287)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-52\" transform=\"translate(0 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-59\" transform=\"translate(70.439453 -16.3125)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"line2d_57\">\n",
       "    <path d=\"M 1242.788335 189.371218 \n",
       "L 1242.788335 177.319178 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_58\">\n",
       "    <path d=\"M 1236.762315 183.345198 \n",
       "L 1248.814355 183.345198 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke: #ffffff; stroke-width: 2; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"text_53\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- 1.22 -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(121.3861 472.715724)scale(0.08 -0.08)\">\n",
       "      <use xlink:href=\"#DejaVuSans-31\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-32\" x=\"95.410156\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-32\" x=\"159.033203\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_54\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- $\\mathrm{R_Y}$ -->\n",
       "     <g style=\"fill: #ffffff\" transform=\"translate(122.75235 460.536867)scale(0.13 -0.13)\">\n",
       "      <use xlink:href=\"#DejaVuSans-52\" transform=\"translate(0 0.09375)\"/>\n",
       "      <use xlink:href=\"#DejaVuSans-59\" transform=\"translate(70.439453 -16.3125)scale(0.7)\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"line2d_59\">\n",
       "    <path d=\"M 176.646349 299.230196 \n",
       "L 176.646349 345.584196 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke-dasharray: 3.7,1.6; stroke-dashoffset: 0; stroke: #000000\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_60\">\n",
       "    <path d=\"M 176.646349 345.584196 \n",
       "L 176.646349 391.938195 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke-dasharray: 3.7,1.6; stroke-dashoffset: 0; stroke: #000000\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_61\">\n",
       "    <path d=\"M 176.646349 391.938195 \n",
       "L 176.646349 438.292194 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke-dasharray: 3.7,1.6; stroke-dashoffset: 0; stroke: #000000\"/>\n",
       "   </g>\n",
       "   <g id=\"line2d_62\">\n",
       "    <path d=\"M 176.646349 438.292194 \n",
       "L 176.646349 484.646194 \n",
       "\" clip-path=\"url(#pcaba245efd)\" style=\"fill: none; stroke-dasharray: 3.7,1.6; stroke-dashoffset: 0; stroke: #000000\"/>\n",
       "   </g>\n",
       "   <g id=\"text_55\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- 0 -->\n",
       "     <g transform=\"translate(234.588849 501.024918)scale(0.104 -0.104)\">\n",
       "      <use xlink:href=\"#DejaVuSans-30\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_56\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- 1 -->\n",
       "     <g transform=\"translate(280.942848 501.024918)scale(0.104 -0.104)\">\n",
       "      <use xlink:href=\"#DejaVuSans-31\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_57\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- 2 -->\n",
       "     <g transform=\"translate(327.296847 501.024918)scale(0.104 -0.104)\">\n",
       "      <use xlink:href=\"#DejaVuSans-32\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"text_58\">\n",
       "    <g clip-path=\"url(#pcaba245efd)\">\n",
       "     <!-- 3 -->\n",
       "     <g transform=\"translate(373.650847 501.024918)scale(0.104 -0.104)\">\n",
       "      <use xlink:href=\"#DejaVuSans-33\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "  </g>\n",
       " </g>\n",
       " <defs>\n",
       "  <clipPath id=\"pcaba245efd\">\n",
       "   <rect x=\"7.2\" y=\"7.2\" width=\"1266.181975\" height=\"528.435593\"/>\n",
       "  </clipPath>\n",
       " </defs>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<Figure size 2283.88x953.167 with 1 Axes>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import QuantumRegister, QuantumCircuit\n",
    "import numpy as np\n",
    "\n",
    "t = 2  # This is not optimal; As an exercise, set this to the\n",
    "       # value that will get the best results. See section 8 for solution.\n",
    "\n",
    "nqubits = 4  # Total number of qubits\n",
    "nb = 1  # Number of qubits representing the solution\n",
    "nl = 2  # Number of qubits representing the eigenvalues\n",
    "\n",
    "theta = 0  # Angle defining |b>\n",
    "\n",
    "a = 1  # Matrix diagonal\n",
    "b = -1/3  # Matrix off-diagonal\n",
    "\n",
    "# Initialize the quantum and classical registers\n",
    "qr = QuantumRegister(nqubits)\n",
    "\n",
    "# Create a Quantum Circuit\n",
    "qc = QuantumCircuit(qr)\n",
    "\n",
    "qrb = qr[0:nb]\n",
    "qrl = qr[nb:nb+nl]\n",
    "qra = qr[nb+nl:nb+nl+1]\n",
    "\n",
    "# State preparation. \n",
    "qc.ry(2*theta, qrb[0])\n",
    "    \n",
    "# QPE with e^{iAt}\n",
    "for qu in qrl:\n",
    "    qc.h(qu)\n",
    "\n",
    "qc.p(a*t, qrl[0])\n",
    "qc.p(a*t*2, qrl[1])\n",
    "\n",
    "qc.u(b*t, -np.pi/2, np.pi/2, qrb[0])\n",
    "\n",
    "\n",
    "# Controlled e^{iAt} on \\lambda_{1}:\n",
    "params=b*t\n",
    "\n",
    "qc.p(np.pi/2,qrb[0])\n",
    "qc.cx(qrl[0],qrb[0])\n",
    "qc.ry(params,qrb[0])\n",
    "qc.cx(qrl[0],qrb[0])\n",
    "qc.ry(-params,qrb[0])\n",
    "qc.p(3*np.pi/2,qrb[0])\n",
    "\n",
    "# Controlled e^{2iAt} on \\lambda_{2}:\n",
    "params = b*t*2\n",
    "\n",
    "qc.p(np.pi/2,qrb[0])\n",
    "qc.cx(qrl[1],qrb[0])\n",
    "qc.ry(params,qrb[0])\n",
    "qc.cx(qrl[1],qrb[0])\n",
    "qc.ry(-params,qrb[0])\n",
    "qc.p(3*np.pi/2,qrb[0])\n",
    "\n",
    "# Inverse QFT\n",
    "qc.h(qrl[1])\n",
    "qc.rz(-np.pi/4,qrl[1])\n",
    "qc.cx(qrl[0],qrl[1])\n",
    "qc.rz(np.pi/4,qrl[1])\n",
    "qc.cx(qrl[0],qrl[1])\n",
    "qc.rz(-np.pi/4,qrl[0])\n",
    "qc.h(qrl[0])\n",
    "\n",
    "# Eigenvalue rotation\n",
    "t1=(-np.pi +np.pi/3 - 2*np.arcsin(1/3))/4\n",
    "t2=(-np.pi -np.pi/3 + 2*np.arcsin(1/3))/4\n",
    "t3=(np.pi -np.pi/3 - 2*np.arcsin(1/3))/4\n",
    "t4=(np.pi +np.pi/3 + 2*np.arcsin(1/3))/4\n",
    "\n",
    "qc.cx(qrl[1],qra[0])\n",
    "qc.ry(t1,qra[0])\n",
    "qc.cx(qrl[0],qra[0])\n",
    "qc.ry(t2,qra[0])\n",
    "qc.cx(qrl[1],qra[0])\n",
    "qc.ry(t3,qra[0])\n",
    "qc.cx(qrl[0],qra[0])\n",
    "qc.ry(t4,qra[0])\n",
    "qc.measure_all()\n",
    "\n",
    "print(\"Depth: %i\" % qc.depth())\n",
    "print(\"CNOTS: %i\" % qc.count_ops()['cx'])\n",
    "qc.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code below takes as inputs our circuit, the real hardware backend and the set of qubits we want to use, and returns and instance that can be run on the specified device. Creating the circuits with $3$ and $5$ CNOTs is the same but calling the transpile method with the right quantum circuit.\n",
    "\n",
    "Real hardware devices need to be recalibrated regularly, and the fidelity of a specific qubit or gate can change over time. Furthermore, different chips have different connectivities. If we try to run a circuit that performs a two-qubit gate between two qubits that are not connected on the specified device, the transpiler will add SWAP gates. Therefore it is good practice to check with the IBM Quantum Experience webpage<sup>[[7]](#qexperience)</sup> before running the following code and choose a set of qubits with the right connectivity and lowest error rates at the given time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "tags": [
     "uses-hardware"
    ]
   },
   "outputs": [],
   "source": [
    "from qiskit import ClassicalRegister, IBMQ\n",
    "from qiskit.compiler import transpile\n",
    "from qiskit.utils.mitigation import (complete_meas_cal,\n",
    "                                     CompleteMeasFitter)\n",
    "\n",
    "from qiskit.providers.fake_provider import FakeYorktown\n",
    "backend = FakeYorktown()\n",
    "layout = [2,3,0,4]\n",
    "chip_qubits = 5\n",
    "\n",
    "# Transpiled circuit for the real hardware\n",
    "qc_qa_cx = transpile(qc, backend=backend, initial_layout=layout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step is to create the extra circuits used to mitigate the readout errors<sup>[[3]](#readouterr)</sup>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "tags": [
     "uses-hardware"
    ]
   },
   "outputs": [],
   "source": [
    "meas_cals, state_labels = complete_meas_cal(qubit_list=layout, qr=QuantumRegister(chip_qubits))\n",
    "qcs = meas_cals + [qc_qa_cx]\n",
    "\n",
    "job = backend.run(qcs, shots=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following plot<sup>[[5]](#tridi)</sup>, shows the results from running the circuit above on real hardware for $10$ different initial states. The $x$-axis represents the angle $\\theta$ defining the initial state in each case. The results where obtained after mitigating the readout error and then extrapolating the errors arising during the run of the circuit from the results with the circuits with $1$, $3$ and $5$ CNOTs. \n",
    "\n",
    "<img src=\"images/norm_public.png\">\n",
    "\n",
    "Compare to the results without error mitigation nor extrapolation from the CNOTs<sup>[5](#tridi)</sup>.\n",
    "\n",
    "<img src=\"images/noerrmit_public.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Problems<a id='problems'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Real hardware:\n",
    "\n",
    "1. Set the time parameter for the optimised example.\n",
    "\n",
    "<details>\n",
    "    <summary> Solution (Click to expand)</summary>\n",
    "    t = 2.344915690192344\n",
    "\n",
    "The best result is to set it so that the smallest eigenvalue can be represented exactly, since it's inverse will have the largest contribution in the solution\n",
    "</details>\n",
    "\n",
    "2. Create transpiled circuits for $3$ and $5$ CNOTs from a given circuit 'qc'. When creating the circuits you will have to add barriers so that these consecutive CNOT gates do not get cancelled when using the transpile() method.\n",
    "\n",
    "3. Run your circuits on the real hardware and apply a quadratic fit to the results to obtain the extrapolated value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. References<a id='references'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. A. W. Harrow, A. Hassidim, and S. Lloyd, (2009). “Quantum algorithm for linear systems of equations”. Phys. Rev. Lett. 103.15, p. 150502.<a id='hhl'></a>\n",
    "\n",
    "2. J. R. Shewchuk. (1994). “An Introduction to the Conjugate Gradient Method Without the Agonizing Pain”. Technical Report CMU-CS-94-125, School of Computer Science, Carnegie Mellon University, Pittsburgh, Pennsylvania.<a id='conjgrad'></a> \n",
    "\n",
    "3. Wiebe, Nathan & Braun, Daniel & Lloyd, Seth. (2012). “Quantum Algorithm for Data Fitting”. Phys. Rev. Lett. 109. 10.1103/PhysRevLett.109.050505. <a id=‘ml’></a> \n",
    "\n",
    "4. Perelshtein, M.R., Pakhomchik, A.I., Melnikov, A.A., Novikov, A.A., Glatz, A., Paraoanu, G.S., Vinokur, V.M. and Lesovik, G.B. (2022). “Solving Large‐Scale Linear Systems of Equations by a Quantum Hybrid Algorithm”. Annalen der Physik, p.2200082. doi:10.1002/andp.202200082. <a id=‘ml’></a> \n",
    "\n",
    "5. A. Dewes, F. R. Ong, V. Schmitt, R. Lauro, N. Boulant, P. Bertet, D. Vion, and D. Esteve (2012). “Characterization of a two-transmon processor with individual single-shot qubit readout.” Phys. Rev. Lett. 108, 057002. <a id='readouterr'></a>\n",
    "\n",
    "6. N. Stamatopoulos, D. J. Egger, Y. Sun, C. Zoufal, R. Iten, N. Shen, and S. Woerner. “Option Pricing using Quantum Computers”. arXiv:1905.02666. <a id='richardson'></a>\n",
    "\n",
    "7. A. Carrera Vazquez, A. Frisch, D. Steenken, H. S. Barowski, R. Hiptmair, and S. Woerner. “Enhancing Quantum Linear System Algorithm by Richardson Extrapolation,” (to be included).<a id='tridi'></a>\n",
    "\n",
    "8. R. Iten, O. Reardon-Smith, L. Mondada, E. Redmond, R. Singh Kohli, R. Colbeck. “Introduction to UniversalQCompiler”. arXiv:1904.01072.<a id='qcompiler'></a>\n",
    "\n",
    "9. https://quantum-computing.ibm.com/.<a id='qexperience'></a>\n",
    "\n",
    "10. D. Bucher, J. Mueggenburg, G. Kus, I. Haide, S. Deutschle, H. Barowski, D. Steenken, A. Frisch, “Qiskit Aqua: Solving linear systems of equations with the HHL algorithm”. https://github.com/Qiskit/qiskit-tutorials/blob/master/legacy_tutorials/aqua/linear_systems_of_equations.ipynb."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td><code>qiskit-terra</code></td><td>0.21.2</td></tr><tr><td><code>qiskit-aer</code></td><td>0.10.4</td></tr><tr><td><code>qiskit-ibmq-provider</code></td><td>0.19.2</td></tr><tr><td><code>qiskit</code></td><td>0.37.2</td></tr><tr><td><code>qiskit-nature</code></td><td>0.4.1</td></tr><tr><td><code>qiskit-finance</code></td><td>0.3.2</td></tr><tr><td><code>qiskit-optimization</code></td><td>0.4.0</td></tr><tr><td><code>qiskit-machine-learning</code></td><td>0.4.0</td></tr><tr><th>System information</th></tr><tr><td>Python version</td><td>3.8.13</td></tr><tr><td>Python compiler</td><td>Clang 13.1.6 (clang-1316.0.21.2.5)</td></tr><tr><td>Python build</td><td>default, Aug 29 2022 05:17:23</td></tr><tr><td>OS</td><td>Darwin</td></tr><tr><td>CPUs</td><td>8</td></tr><tr><td>Memory (Gb)</td><td>32.0</td></tr><tr><td colspan='2'>Mon Sep 05 15:12:38 2022 BST</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import qiskit.tools.jupyter\n",
    "%qiskit_version_table"
   ]
  }
 ],
 "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.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}