diff --git a/pr-2023/_images/Bloch_sphere.png b/pr-2023/_images/Bloch_sphere.png new file mode 100644 index 0000000000..36d9e393c1 Binary files /dev/null and b/pr-2023/_images/Bloch_sphere.png differ diff --git a/pr-2023/_images/circuit_pdf.png b/pr-2023/_images/circuit_pdf.png new file mode 100644 index 0000000000..b5c85f495d Binary files /dev/null and b/pr-2023/_images/circuit_pdf.png differ diff --git a/pr-2023/_images/examples_python_tutorials_Divisive_clustering_11_0.png b/pr-2023/_images/examples_python_tutorials_Divisive_clustering_11_0.png new file mode 100644 index 0000000000..60fd27f546 Binary files /dev/null and b/pr-2023/_images/examples_python_tutorials_Divisive_clustering_11_0.png differ diff --git a/pr-2023/_images/examples_python_tutorials_Divisive_clustering_29_0.png b/pr-2023/_images/examples_python_tutorials_Divisive_clustering_29_0.png new file mode 100644 index 0000000000..c32b1924a5 Binary files /dev/null and b/pr-2023/_images/examples_python_tutorials_Divisive_clustering_29_0.png differ diff --git a/pr-2023/_images/examples_python_tutorials_Divisive_clustering_31_0.png b/pr-2023/_images/examples_python_tutorials_Divisive_clustering_31_0.png new file mode 100644 index 0000000000..a37b6b65a9 Binary files /dev/null and b/pr-2023/_images/examples_python_tutorials_Divisive_clustering_31_0.png differ diff --git a/pr-2023/_images/examples_python_tutorials_Divisive_clustering_33_0.png b/pr-2023/_images/examples_python_tutorials_Divisive_clustering_33_0.png new file mode 100644 index 0000000000..de8f7919d5 Binary files /dev/null and b/pr-2023/_images/examples_python_tutorials_Divisive_clustering_33_0.png differ diff --git a/pr-2023/_images/examples_python_tutorials_Divisive_clustering_35_0.png b/pr-2023/_images/examples_python_tutorials_Divisive_clustering_35_0.png new file mode 100644 index 0000000000..45758e2697 Binary files /dev/null and b/pr-2023/_images/examples_python_tutorials_Divisive_clustering_35_0.png differ diff --git a/pr-2023/_images/examples_python_tutorials_Divisive_clustering_37_0.png b/pr-2023/_images/examples_python_tutorials_Divisive_clustering_37_0.png new file mode 100644 index 0000000000..e0c354941b Binary files /dev/null and b/pr-2023/_images/examples_python_tutorials_Divisive_clustering_37_0.png differ diff --git a/pr-2023/_images/examples_python_tutorials_visualization_11_0.png b/pr-2023/_images/examples_python_tutorials_visualization_11_0.png new file mode 100644 index 0000000000..de449d6da9 Binary files /dev/null and b/pr-2023/_images/examples_python_tutorials_visualization_11_0.png differ diff --git a/pr-2023/_images/examples_python_tutorials_visualization_13_0.png b/pr-2023/_images/examples_python_tutorials_visualization_13_0.png new file mode 100644 index 0000000000..cf826962ea Binary files /dev/null and b/pr-2023/_images/examples_python_tutorials_visualization_13_0.png differ diff --git a/pr-2023/_images/examples_python_tutorials_visualization_17_0.png b/pr-2023/_images/examples_python_tutorials_visualization_17_0.png new file mode 100644 index 0000000000..db4a50c25c Binary files /dev/null and b/pr-2023/_images/examples_python_tutorials_visualization_17_0.png differ diff --git a/pr-2023/_images/examples_python_tutorials_visualization_7_0.png b/pr-2023/_images/examples_python_tutorials_visualization_7_0.png new file mode 100644 index 0000000000..82f09dda11 Binary files /dev/null and b/pr-2023/_images/examples_python_tutorials_visualization_7_0.png differ diff --git a/pr-2023/_images/examples_python_tutorials_visualization_9_0.png b/pr-2023/_images/examples_python_tutorials_visualization_9_0.png new file mode 100644 index 0000000000..e906b29da0 Binary files /dev/null and b/pr-2023/_images/examples_python_tutorials_visualization_9_0.png differ diff --git a/pr-2023/_sources/api/default_ops.rst.txt b/pr-2023/_sources/api/default_ops.rst.txt index 6b1a33ebc9..c82271e826 100644 --- a/pr-2023/_sources/api/default_ops.rst.txt +++ b/pr-2023/_sources/api/default_ops.rst.txt @@ -541,4 +541,95 @@ This is a non-linear transformation, and no template overloads are available. .. code-block:: cpp cudaq::qubit qubit; - my(qubit); \ No newline at end of file + my(qubit); + + +User-Defined Custom Operations +============================== + +Users can define a custom quantum operation by its unitary matrix. First use +the API to register a custom operation, outside of a CUDA-Q kernel. Then the +operation can be used within a CUDA-Q kernel like any of the built-in operations +defined above. +Custom operations are supported on qubits only (`qudit` with `level = 2`). + +.. tab:: Python + + The :code:`cudaq.register_operation` API accepts an identifier string for + the custom operation and its unitary matrix. The matrix can be a `list` or + `numpy` array of complex numbers. A 1D matrix is interpreted as row-major. + + + .. code-block:: python + + import cudaq + import numpy as np + + cudaq.register_operation("custom_h", 1. / np.sqrt(2.) * np.array([1, 1, 1, -1])) + + cudaq.register_operation("custom_x", np.array([0, 1, 1, 0])) + + @cudaq.kernel + def bell(): + qubits = cudaq.qvector(2) + custom_h(qubits[0]) + custom_x.ctrl(qubits[0], qubits[1]) + + cudaq.sample(bell).dump() + + +.. tab:: C++ + + The macro :code:`CUDAQ_REGISTER_OPERATION` accepts a unique name for the + operation, the number of target qubits, the number of rotation parameters + (can be 0), and the unitary matrix as a 1D row-major `std::vector` + representation. + + .. code-block:: cpp + + #include + + CUDAQ_REGISTER_OPERATION(custom_h, 1, 0, + {M_SQRT1_2, M_SQRT1_2, M_SQRT1_2, -M_SQRT1_2}) + + CUDAQ_REGISTER_OPERATION(custom_x, 1, 0, {0, 1, 1, 0}) + + __qpu__ void bell_pair() { + cudaq::qubit q, r; + custom_h(q); + custom_x(q, r); + } + + int main() { + auto counts = cudaq::sample(bell_pair); + for (auto &[bits, count] : counts) { + printf("%s\n", bits.data()); + } + } + + +For multi-qubit operations, the matrix is interpreted with MSB qubit ordering, +i.e. big-endian convention. The following example shows two different custom +operations, each operating on 2 qubits. + + +.. tab:: Python + + .. literalinclude:: ../snippets/python/using/examples/two_qubit_custom_op.py + :language: python + :start-after: [Begin Docs] + :end-before: [End Docs] + + +.. tab:: C++ + + .. literalinclude:: ../snippets/cpp/using/two_qubit_custom_op.cpp + :language: cpp + :start-after: [Begin Docs] + :end-before: [End Docs] + + +.. note:: + + Custom operations are currently supported only on :doc:`../using/backends/simulators`. + Attempt to use with a hardware backend will result in runtime error. diff --git a/pr-2023/_sources/examples/python/tutorials/Divisive_clustering.ipynb.txt b/pr-2023/_sources/examples/python/tutorials/Divisive_clustering.ipynb.txt new file mode 100644 index 0000000000..b3730dcb43 --- /dev/null +++ b/pr-2023/_sources/examples/python/tutorials/Divisive_clustering.ipynb.txt @@ -0,0 +1,1088 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Divisive Clustering With Coresets Using CUDA-Q" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This tutorial will explore a CUDA-Q implementation of recent research (ArXiv Paper: https://arxiv.org/pdf/2402.01529.pdf) performed by a team from the University of Edinburgh. This tutorial was jointly developed by NVIDIA and the authors so users can better understand their method and explore how CUDA-Q removed barriers to scaling. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The code for this tutorial is based off the MIT licensed code found here: https://github.com/Boniface316/bigdata_vqa" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Clustering is a common unsupervised learning technique aimed at grouping data with similar characteristics. The unique properties of quantum computers could allow for enhanced pattern finding in clustering applications and enable more reliable data analysis. However, quantum computers today are severely limited by qubit count and noise. Performing practical clustering applications would require far too many qubits. The Edinburgh team developed a new method (extending the work of Harrow) to leverage coresets for clustering applications on quantum computers and use far fewer qubits. This tutorial will walk through an example using this approach for divisive clustering and emphasize the utility of CUDA-Q for scaling quantum simulations.\n", + "\n", + "The goal of divisive clustering is to begin with all data points as one set, and iteratively bipartition the data until each point is its own cluster. The branching behavior of this process can be used to understand similarities in the data points.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# If you are running outside of a CUDA-Q container or CUDA-Q directory tree, you may need to uncomment these lines to fetch the files.\n", + "# If you are running inside a CUDA-Q tree, then this step can be skipped.\n", + "# !mkdir divisive_clustering_src\n", + "# !wget -P divisive_clustering_src https://raw.githubusercontent.com/NVIDIA/cuda-quantum/main/docs/sphinx/examples/python/tutorials/divisive_clustering_src/divisive_clustering.py\n", + "# !wget -P divisive_clustering_src https://raw.githubusercontent.com/NVIDIA/cuda-quantum/main/docs/sphinx/examples/python/tutorials/divisive_clustering_src/main_divisive_clustering.py" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Install the relevant packages.\n", + "!pip install mpi4py==3.1.6\n", + "!pip install networkx==2.8.8\n", + "!pip install pandas==2.2.2\n", + "!pip install scikit-learn==1.4.2\n", + "!pip install tqdm==4.66.2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import cudaq\n", + "from cudaq import spin\n", + "\n", + "\n", + "# Auxillary Imports\n", + "import os\n", + "import numpy as np\n", + "import networkx as nx\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import warnings\n", + "from typing import Tuple\n", + "from divisive_clustering_src.divisive_clustering import Coreset, DivisiveClustering, Dendrogram, Voironi_Tessalation\n", + "\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The settings below are global parameters for the quantum simulation and can be toggled by the user. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "circuit_depth = 1\n", + "max_iterations = 75\n", + "max_shots = 1000" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "Given a data set $X = (x_1, x_2, \\cdots, x_N)$, a coreset is weighted data set of much smaller size ($X', w$) that represents $X$ enough such that analysis of ($X', w$) can allow us to draw reasonable approximate conclusions about $X$. There are various approaches to build coresets. They can be found in Practical Coreset Construction for Machine Learning (https://arxiv.org/pdf/1703.06476.pdf) and New Streaming Algorithms for Coresets in Machine Learning (https://arxiv.org/pdf/1703.06476.pdf).\n", + "\n", + "\n", + "Essentially, coreset construction boils down to finding the optimal coreset size and weights given some error tolerance. Given the constraints of a quantum computer, in this work, a coreset size is selected $a$ $priori$, and the error is determined for each model.\n", + "\n", + "\n", + "The following is an example $M=10$ coreset constructed from a 1000-point data set and loaded into a pandas data frame. See the image below where the coreset is represented by the black stars, the size of which corresponds to the weights.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using BFL2 method to generate coresets\n", + " X Y weights Name\n", + "0 7.028364 1.669787 234.230716 A\n", + "1 7.167441 0.354792 101.319288 B\n", + "2 1.022889 -0.921443 125.158339 C\n", + "3 2.706134 -2.636852 13.650774 D\n", + "4 6.998497 0.455847 116.758239 E\n", + "5 7.507918 0.630311 120.727176 F\n", + "6 -2.102508 2.297727 53.294127 G\n", + "7 5.722463 1.400433 77.415840 H\n", + "8 -1.425868 2.341136 42.847985 I\n", + "9 7.985373 -0.063209 240.116237 J\n" + ] + } + ], + "source": [ + "raw_data = Coreset.create_dataset(1000)\n", + "coreset = Coreset(\n", + " raw_data=raw_data,\n", + " number_of_sampling_for_centroids=10,\n", + " coreset_size=10,\n", + " number_of_coresets_to_evaluate=4,\n", + " coreset_method=\"BFL2\",\n", + ")\n", + "\n", + "\n", + "coreset_vectors, coreset_weights = coreset.get_best_coresets()\n", + "\n", + "coreset_df = pd.DataFrame(\n", + " {\"X\": coreset_vectors[:, 0], \"Y\": coreset_vectors[:, 1], \"weights\": coreset_weights}\n", + ")\n", + "coreset_df[\"Name\"] = [chr(i + 65) for i in coreset_df.index]\n", + "print(coreset_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(raw_data[:, 0], raw_data[:, 1], label=\"Raw Data\", c=\"#7eba00\")\n", + "plt.scatter(\n", + " coreset_df[\"X\"],\n", + " coreset_df[\"Y\"],\n", + " s=coreset_df[\"weights\"],\n", + " label=\"Coreset\",\n", + " color=\"black\",\n", + " marker=\"*\",\n", + ")\n", + "plt.xlabel(\"X\")\n", + "plt.ylabel(\"Y\")\n", + "plt.title(\"Raw data and its best 10 coreset using BFL2\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data preprocessing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to cluster data on a quantum computer, the task needs to be cast into the form of a binary optimization problem. Each qubit represents a coreset point, and the quantum algorithm determines how to bipartition the coreset points at each iteration of the divisive clustering routine. \n", + "\n", + "The first step is to convert coreset points into a fully connected graph. The edge weight is calculated by:\n", + "\n", + "$e_{ij} = w_iw_jd_{ij}$ where $d_{ij}$ is the Euclidean distance between points $i$ and $j$. \n", + "\n", + "This process is handled by `Coreset.coreset_to_graph()`. The function returns a fully connected graph $G$ with edge weights." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quantum functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The divisive clustering problem will be implemented on a quantum computer using a variational quantum algorithm (VQA) approach. A VQA takes a Hamiltonian (encoded with the optimization problem) and a parameterized ansatz and evaluates expectation values (quantum computer) that inform updates to the ansatz parameters (classical computer). The graph $G$ (Code in the \"src\" file) is used to construct the Hamiltonian, derived specifically for the divisive clustering problem, and motivated by a max-cut Hamiltonian. The `spin.z(i)` method in CUDA-Q adds a Pauli Z operation that acts on qubit $i$ to the Hamiltonian." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def get_K2_Hamiltonian(G: nx.Graph) -> cudaq.SpinOperator:\n", + " \"\"\"Returns the K2 Hamiltonian for the given graph G\n", + "\n", + " Args:\n", + " G (nx.Graph): Weighted graph\n", + " \"\"\"\n", + " H = 0\n", + "\n", + " for i, j in G.edges():\n", + " weight = G[i][j][\"weight\"]\n", + " H += weight * (spin.z(i) * spin.z(j))\n", + "\n", + " return H" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The code below constructs a quantum kernel, defining the circuit which will serve as an ansatz. The structure of the circuit is a hardware efficient ansatz consisting of layers of parameterized $R_Z$ and $R_Y$ gate acting on each qubit, followed by a linear cascade of CNOT gates, and two more rotation gates.\n", + "\n", + "The `@cudaq.kernel` decorator allows us to define a quantum circuit in the new kernel mode syntax which provides performance benefits to JIT compilation." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def get_VQE_circuit(number_of_qubits: int, circuit_depth: int) -> cudaq.Kernel:\n", + " \"\"\"Returns the VQE circuit for the given number of qubits and circuit depth\n", + "\n", + " Args:\n", + " number_of_qubits (int): Number of qubits\n", + " circuit_depth (int): Circuit depth\n", + "\n", + " Returns:\n", + " cudaq.Kernel: VQE Circuit\n", + " \"\"\"\n", + "\n", + " @cudaq.kernel\n", + " def kernel(thetas: list[float], number_of_qubits: int, circuit_depth: int):\n", + " \"\"\"VQE Circuit\n", + "\n", + " Args:\n", + " thetas (list[float]): List of parameters\n", + " number_of_qubits (int): Number of qubits\n", + " circuit_depth (int): Circuit depth\n", + " \"\"\"\n", + " qubits = cudaq.qvector(number_of_qubits)\n", + "\n", + " theta_position = 0\n", + "\n", + " for i in range(circuit_depth):\n", + " for j in range(number_of_qubits):\n", + " ry(thetas[theta_position], qubits[j])\n", + " rz(thetas[theta_position + 1], qubits[j])\n", + "\n", + " theta_position += 2\n", + "\n", + " for j in range(number_of_qubits - 1):\n", + " cx(qubits[j], qubits[j + 1])\n", + "\n", + " for j in range(number_of_qubits):\n", + " ry(thetas[theta_position], qubits[j])\n", + " rz(thetas[theta_position + 1], qubits[j])\n", + "\n", + " theta_position += 2\n", + "\n", + " return kernel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can visualize the circuit using the `cudaq.draw()` method. Below, we are drawing the circuit for 5 qubits." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ╭────────────╮ ╭────────────╮ ╭────────────╮╭────────────╮»\n", + "q0 : ┤ ry(0.8904) ├─┤ rz(0.7335) ├───●──┤ ry(0.4343) ├┤ rz(0.2236) ├»\n", + " ├────────────┤ ├────────────┤ ╭─┴─╮╰────────────╯├────────────┤»\n", + "q1 : ┤ ry(0.7937) ├─┤ rz(0.9981) ├─┤ x ├──────●───────┤ ry(0.3945) ├»\n", + " ├───────────┬╯ ├────────────┤ ╰───╯ ╭─┴─╮ ╰────────────╯»\n", + "q2 : ┤ ry(0.696) ├──┤ rz(0.3352) ├──────────┤ x ├───────────●───────»\n", + " ├───────────┴╮╭┴────────────┤ ╰───╯ ╭─┴─╮ »\n", + "q3 : ┤ ry(0.6658) ├┤ rz(0.05277) ├────────────────────────┤ x ├─────»\n", + " ├───────────┬╯├─────────────┴╮ ╰───╯ »\n", + "q4 : ┤ ry(0.791) ├─┤ rz(0.003569) ├─────────────────────────────────»\n", + " ╰───────────╯ ╰──────────────╯ »\n", + "\n", + "################################################################################\n", + "\n", + " \n", + "─────────────────────────────────────────────\n", + "╭────────────╮ \n", + "┤ rz(0.4119) ├───────────────────────────────\n", + "├────────────┤╭────────────╮ \n", + "┤ ry(0.3205) ├┤ rz(0.3504) ├─────────────────\n", + "╰────────────╯├────────────┤ ╭────────────╮ \n", + "──────●───────┤ ry(0.3913) ├─┤ rz(0.7392) ├──\n", + " ╭─┴─╮ ├────────────┤╭┴────────────┴─╮\n", + "────┤ x ├─────┤ ry(0.3171) ├┤ rz(0.0008056) ├\n", + " ╰───╯ ╰────────────╯╰───────────────╯\n", + "\n" + ] + } + ], + "source": [ + "parameter_count = 4 * circuit_depth * 5\n", + "parameters = np.random.rand(parameter_count)\n", + "\n", + "circuit = get_VQE_circuit(5, circuit_depth)\n", + "print(cudaq.draw(circuit, parameters, 5, circuit_depth))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next step is to select a classical optimizer. There are multiple [optimizers](https://nvidia.github.io/cuda-quantum/latest/api/languages/python_api.html#optimizers) built-in to CUDA-Q that can be selected. The code below returns the optimizer with the proper number of initial parameters. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def get_optimizer(\n", + " optimizer: cudaq.optimizers.optimizer, max_iterations, **kwargs\n", + ") -> Tuple[cudaq.optimizers.optimizer, int]:\n", + " \"\"\"Returns the optimizer with the given parameters\n", + "\n", + " Args:\n", + " optimizer (cudaq.optimizers.optimizer): Optimizer\n", + " max_iterations (int): Maximum number of iterations\n", + " **kwargs: Additional arguments\n", + "\n", + " Returns:\n", + " tuple(cudaq.optimizers.optimizer, int): Optimizer and parameter count\n", + " \"\"\"\n", + " parameter_count = 4 * kwargs[\"circuit_depth\"] * kwargs[\"qubits\"]\n", + " initial_params = np.random.uniform(-np.pi / 8.0, np.pi / 8.0, parameter_count)\n", + " optimizer.initial_parameters = initial_params\n", + "\n", + " optimizer.max_iterations = max_iterations\n", + " return optimizer, parameter_count" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Divisive Clustering Function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `DivisiveClusteringVQA` class enables the procedure to iteratively bipartition the coreset points until each is its own cluster. If you wish to develop on top of this or see how the underlying code works, please see the `divisive_clustering.py` file in the src directory. \n", + "\n", + "`run_divisive_clustering`, takes the current iteration's coreset points that will be bipartitioned as inputs, extracts the appropriate weights, and builds a graph $G$. The graph is then an input into the `get_counts_from_simulation` function. \n", + "\n", + "\n", + "`get_counts_from_simulation` handles preparation and execution of the quantum simulation. First, it takes $G$ and from it builds a spin Hamiltonian. Second, it defines a cost function, which in this case is a lambda function that returns the expectation value of our parameterized quantum circuit and the Hamiltonian. This value is obtained using the CUDA-Q `observe` command, accelerated by GPUs. After the expectation value is minimized, the quantum circuit corresponding to the optimal parameters is sampled using the CUDA-Q `sample` function. The bitstrings and their associated counts are returned by `get_counts_from_simulation`.\n", + "\n", + "A subset of these counts is evaluated to compute their exact cost. The best bitstring is returned and later used to assign the coreset points to one of two clusters.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "class DivisiveClusteringVQA(DivisiveClustering):\n", + " def __init__(\n", + " self,\n", + " **kwargs,\n", + " ):\n", + " super().__init__(**kwargs)\n", + "\n", + " def run_divisive_clustering(\n", + " self,\n", + " coreset_vectors_df_for_iteration: pd.DataFrame,\n", + " ):\n", + " \"\"\"Runs the Divisive Clustering algorithm\n", + "\n", + " Args:\n", + " coreset_vectors_df_for_iteration (pd.DataFrame): Coreset vectors for the iteration\n", + "\n", + " Returns:\n", + " str: Best bitstring\n", + "\n", + " \"\"\"\n", + " coreset_vectors_for_iteration_np, coreset_weights_for_iteration_np = (\n", + " self._get_iteration_coreset_vectors_and_weights(coreset_vectors_df_for_iteration)\n", + " )\n", + "\n", + " G = Coreset.coreset_to_graph(\n", + " coreset_vectors_for_iteration_np,\n", + " coreset_weights_for_iteration_np,\n", + " metric=self.coreset_to_graph_metric,\n", + " )\n", + "\n", + " counts = self.get_counts_from_simulation(\n", + " G,\n", + " self.circuit_depth,\n", + " self.max_iterations,\n", + " self.max_shots,\n", + " )\n", + "\n", + " return self._get_best_bitstring(counts, G)\n", + "\n", + " def get_counts_from_simulation(\n", + " self, G: nx.graph, circuit_depth: int, max_iterations: int, max_shots: int\n", + " ) -> cudaq.SampleResult:\n", + " \"\"\"\n", + " Runs the VQA simulation\n", + "\n", + " Args:\n", + " G (nx.graph): Graph\n", + " circuit_depth (int): Circuit depth\n", + " max_iterations (int): Maximum number of iterations\n", + " max_shots (int): Maximum number of shots\n", + "\n", + " Returns:\n", + " cudaq.SampleResult: Measurement from the experiment\n", + " \"\"\"\n", + "\n", + " qubits = len(G.nodes)\n", + " Hamiltonian = self.create_Hamiltonian(G)\n", + " optimizer, parameter_count = self.optimizer_function(\n", + " self.optimizer, max_iterations, qubits=qubits, circuit_depth=circuit_depth\n", + " )\n", + "\n", + " kernel = self.create_circuit(qubits, circuit_depth)\n", + "\n", + " def objective_function(\n", + " parameter_vector: list[float],\n", + " hamiltonian: cudaq.SpinOperator = Hamiltonian,\n", + " kernel: cudaq.Kernel = kernel,\n", + " ) -> float:\n", + " \"\"\"\n", + "\n", + " Objective function that returns the cost of the simulation\n", + "\n", + " Args:\n", + " parameter_vector (List[float]):\n", + " hamiltonian (cudaq.SpinOperator): Circuit parameter values as a vector\n", + " kernel (cudaq.Kernel) : Circuit configuration\n", + "\n", + " Returns:\n", + " float: Expectation value of the circuit\n", + "\n", + " \"\"\"\n", + "\n", + " get_result = lambda parameter_vector: cudaq.observe(\n", + " kernel, hamiltonian, parameter_vector, qubits, circuit_depth\n", + " ).expectation()\n", + "\n", + " cost = get_result(parameter_vector)\n", + "\n", + " return cost\n", + "\n", + " energy, optimal_parameters = optimizer.optimize(\n", + " dimensions=parameter_count, function=objective_function\n", + " )\n", + "\n", + " counts = cudaq.sample(\n", + " kernel, optimal_parameters, qubits, circuit_depth, shots_count=max_shots\n", + " )\n", + "\n", + " return counts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An instance of the `DivisiveClusteringVQA` class is mostly constructed from variables previously discussed like the functions for building the Hamiltonians and quantum circuits. Parameters related to the quantum simulation can also be specified here such as `circuit_depth` and `max_shots`. The ` threshold_for_max_cut` parameter specifies what percent of the sample results from the quantum computer are checked for the best bitstring value.\n", + "\n", + "The other options specify advanced features like if the data is normalized and how the graph weights are computed.\n", + "\n", + "\n", + "Finally, the `get_divisive_sequence` method performs the iterations and produces the clustering data which we will analyze below. Note that this postprocessing code is not exposed in this tutorial but can be found in the source code. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 129/129 [00:00<00:00, 12075.19it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 35025.50it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 18/18 [00:00<00:00, 44254.09it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 15827.56it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 13617.87it/s]\n" + ] + } + ], + "source": [ + "optimizer = cudaq.optimizers.COBYLA()\n", + "\n", + "divisive_clustering = DivisiveClusteringVQA(\n", + " circuit_depth=circuit_depth,\n", + " max_iterations=max_iterations,\n", + " max_shots=max_shots,\n", + " threshold_for_max_cut=0.75,\n", + " create_Hamiltonian=get_K2_Hamiltonian,\n", + " optimizer=optimizer,\n", + " optimizer_function=get_optimizer,\n", + " create_circuit=get_VQE_circuit,\n", + " normalize_vectors=True,\n", + " sort_by_descending=True,\n", + " coreset_to_graph_metric=\"dist\",\n", + ")\n", + "\n", + "hierarchial_clustering_sequence = divisive_clustering.get_divisive_sequence(coreset_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The data can be nicely visualized with a Dendrogram which maps where the bipartitionings occurred. Early splits generally mark divisions between the least similar data." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dendo = Dendrogram(coreset_df, hierarchial_clustering_sequence)\n", + "dendo.plot_dendrogram(plot_title=\"Dendrogram of Coreset using VQE\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each branch point in the dendrogram aboves corresponds to one of the plots below. Notice the first iterations are the most complicated, and the final iterations become trivial bipartitioning of two points. Occasionally, especially in the first iteration, the partitioning might be puzzling at first glance. The data might seem to naturally cluster into two groups. However, there are cases where a stray point seems to belong in the wrong cluster. There are two explanations for this. 1) The quantum sampling is approximate and stochastic. It is possible that too few shots were taken to sample the ground state of the problem. 2) It is important to remember that we are clustering coresets and not data points. There can be cases where it is optimal to pay a penalty by excluding a point based on proximity if the weights are small enough that the penalty has less impact. Usually, if a point looks unusually clustered and you go look at the original coresets plotted above, that point will have a small weight." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Dendrogram.plot_hierarchial_split(hierarchial_clustering_sequence, coreset_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The hierarchical clustering can be converted to flat clustering by drawing a line perpendicular to the branches. Any data point that intersects the line is considered to be in the same cluster. The function below performs this task at threshold height of 1.5. If you want to use the number of clusters instead of height, you can use `dendo.get_clusters_using_k()` method. You pass the number of desired clusters as an argument. The figure below shows the clusters that are formed at threshold height of 1.5." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "threshold_height = 1\n", + "clusters = dendo.get_clusters_using_height(threshold_height)\n", + "colors = [\"red\", \"blue\", \"green\", \"black\", \"purple\", \"orange\", \"yellow\"]\n", + "dendo.plot_dendrogram(\n", + " plot_title=\"Dendrogram of Coreset using VQE\",\n", + " colors=colors,\n", + " clusters=clusters,\n", + " color_threshold=threshold_height,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can visualize the flat clusters using `dendo.plot_clusters()` method. The function takes the clusters and colors as arguments. The clusters are represented by different colors." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dendo.plot_clusters(\n", + " clusters, colors, plot_title=\"Clusters of Coreset using VQE\", show_annotation=True\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The function below uses the `dendo.get_voronoi_tessalation()` method to convert the clusters into regions. `coreset_df`, `clusters` and `colors` need to be passed as the arguments to create the regions. This function creates a region for each coreset point separately and then colors them according to the clusters with colors passed as arguments. Another option is to create regions using the centroids of the clusters. You need to pass `tesslation_by_cluster=True` to the function to perform this task.\n", + "\n", + "Once the region creation is complete, you can use `plot_voironi()` method to plot the regions. The function takes the clusters and colors as arguments. \n", + "\n", + "Remembering that these regions were based on coresets, they can overlay the original data set and be used to cluster the data based on the coreset analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "vt = Voironi_Tessalation(coreset_df, clusters, colors, tesslation_by_cluster=False)\n", + "vt.plot_voironi(plot_title=\"Voironi Tessalation of Coreset using VQE\", show_annotation=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## QAOA Implementation\n", + "\n", + "CUDA-Q is designed to be a flexible tool for developers so they can test different implementations of the same code. For example, one can perform the same analysis, instead using a QAOA approach. Only the kernel needs to be changed as is done below." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " »\n", + "q0 : ──●──────────────────●──────────────────────────────────────────────────»\n", + " ╭─┴─╮╭────────────╮╭─┴─╮ »\n", + "q1 : ┤ x ├┤ rz(0.3527) ├┤ x ├──●──────────────────●──────────────────────────»\n", + " ╰───╯╰────────────╯╰───╯╭─┴─╮╭────────────╮╭─┴─╮ »\n", + "q2 : ────────────────────────┤ x ├┤ rz(0.3527) ├┤ x ├──●──────────────────●──»\n", + " ╰───╯╰────────────╯╰───╯╭─┴─╮╭────────────╮╭─┴─╮»\n", + "q3 : ────────────────────────────────────────────────┤ x ├┤ rz(0.3527) ├┤ x ├»\n", + " ╰───╯╰────────────╯╰───╯»\n", + "q4 : ────────────────────────────────────────────────────────────────────────»\n", + " »\n", + "\n", + "################################################################################\n", + "\n", + " ╭───╮╭────────────╮╭───╮╭───────────╮\n", + "────────────────────────┤ x ├┤ rz(0.3527) ├┤ x ├┤ rx(1.111) ├\n", + " ╰─┬─╯╰────────────╯╰─┬─╯├───────────┤\n", + "──────────────────────────┼──────────────────┼──┤ rx(1.111) ├\n", + " │ │ ├───────────┤\n", + "──────────────────────────┼──────────────────┼──┤ rx(1.111) ├\n", + " │ │ ├───────────┤\n", + "──●──────────────────●────┼──────────────────┼──┤ rx(1.111) ├\n", + "╭─┴─╮╭────────────╮╭─┴─╮ │ │ ├───────────┤\n", + "┤ x ├┤ rz(0.3527) ├┤ x ├──●──────────────────●──┤ rx(1.111) ├\n", + "╰───╯╰────────────╯╰───╯ ╰───────────╯\n", + "\n" + ] + } + ], + "source": [ + "def get_QAOA_circuit(number_of_qubits, circuit_depth) -> cudaq.Kernel:\n", + " \"\"\"Returns the QAOA circuit for the given number of qubits and circuit depth\n", + "\n", + "\n", + " Args:\n", + " number_of_qubits (int): Number of qubits\n", + " circuit_depth (int): Circuit depth\n", + "\n", + " Returns:\n", + " cudaq.Kernel: QAOA Circuit\n", + " \"\"\"\n", + "\n", + " @cudaq.kernel\n", + " def kernel(thetas: list[float], number_of_qubits: int, circuit_depth: int):\n", + " qubits = cudaq.qvector(number_of_qubits)\n", + "\n", + " layers = circuit_depth\n", + "\n", + " for layer in range(layers):\n", + " for qubit in range(number_of_qubits):\n", + " cx(qubits[qubit], qubits[(qubit + 1) % number_of_qubits])\n", + " rz(2.0 * thetas[layer], qubits[(qubit + 1) % number_of_qubits])\n", + " cx(qubits[qubit], qubits[(qubit + 1) % number_of_qubits])\n", + "\n", + " rx(2.0 * thetas[layer + layers], qubits)\n", + "\n", + " return kernel\n", + "\n", + "\n", + "circuit = get_QAOA_circuit(5, circuit_depth)\n", + "\n", + "print(cudaq.draw(circuit, np.random.rand(2 * circuit_depth), 5, circuit_depth))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def get_optimizer(\n", + " optimizer: cudaq.optimizers.optimizer, max_iterations, **kwargs\n", + ") -> Tuple[cudaq.optimizers.optimizer, int]:\n", + " \"\"\"\n", + " Returns the optimizer with the given parameters\n", + "\n", + " Args:\n", + " optimizer (cudaq.optimizers.optimizer): Optimizer\n", + " max_iterations (int): Maximum number of iterations\n", + " **kwargs: Additional arguments\n", + "\n", + " Returns:\n", + " tuple(cudaq.optimizers.optimizer, int): Optimizer and parameter count\n", + " \"\"\"\n", + "\n", + " parameter_count = 2 * kwargs[\"circuit_depth\"]\n", + " optimizer.initial_parameters = np.random.uniform(-np.pi / 8.0, np.pi / 8.0, parameter_count)\n", + " optimizer.max_iterations = max_iterations\n", + " return optimizer, parameter_count" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 484/484 [00:00<00:00, 12163.89it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 52703.30it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 48/48 [00:00<00:00, 31987.07it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 36393.09it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 37957.50it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 42473.96it/s]\n" + ] + } + ], + "source": [ + "optimizer = cudaq.optimizers.COBYLA()\n", + "\n", + "divisive_clustering = DivisiveClusteringVQA(\n", + " circuit_depth=circuit_depth,\n", + " max_iterations=max_iterations,\n", + " max_shots=max_shots,\n", + " threshold_for_max_cut=0.75,\n", + " create_Hamiltonian=get_K2_Hamiltonian,\n", + " optimizer=optimizer,\n", + " optimizer_function=get_optimizer,\n", + " create_circuit=get_QAOA_circuit,\n", + " normalize_vectors=True,\n", + " sort_by_descending=True,\n", + " coreset_to_graph_metric=\"dist\",\n", + ")\n", + "\n", + "hierarchial_clustering_sequence = divisive_clustering.get_divisive_sequence(coreset_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scaling simulations with CUDA-Q\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The University of Edinburgh team quickly encountered scaling challenges when they were developing this method. By developing with CUDA-Q they were able to port their code to an HPC environment once GPUs became available. GPUs massively accelerated their development and testing and allowed them to produce the 25 qubit experiments presented in their publication. If you have a GPU available, run the following code examples and see how the times compare on your device. Each call executes the divisive clustering procedure using the QAOA method, 100000 simulated shots for each VQE loop, and maximum 75 VQE iterations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, try a slightly larger N=18 problem using the CPU (`qpp-cpu`) backend." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Uncomment the following line if you want to explicitly execute this step on your system.\n", + "# !python3 divisive_clustering_src/main_divisive_clustering.py --target qpp-cpu --M 18" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now try the N=18 example on the GPU backend (`nvidia`)." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using BFL2 method to generate coresets\n", + "100%|███████████████████████████████████████| 751/751 [00:00<00:00, 3460.26it/s]\n", + "100%|████████████████████████████████████████| 16/16 [00:00<00:00, 42771.74it/s]\n", + "100%|█████████████████████████████████████| 4064/4064 [00:00<00:00, 6862.37it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 56871.92it/s]\n", + "100%|████████████████████████████████████████| 16/16 [00:00<00:00, 44979.13it/s]\n", + "100%|██████████████████████████████████████| 128/128 [00:00<00:00, 19366.94it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 53773.13it/s]\n", + "100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 54648.91it/s]\n", + "100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 51941.85it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 56111.09it/s]\n", + "Total time for the execution: 461.866833317\n", + "Total time spent on CUDA-Q: 10.452308367999706\n" + ] + } + ], + "source": [ + "!python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia --M 18" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Scaling up to N=25, the task becomes even more onerous on a CPU. Depending on your device, the simulation may not even run. Try it and feel free to interrupt after your patience has worn out." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# target = 'qpp-cpu'\n", + "# Uncomment the following line if you want to explicitly execute this step on your system.\n", + "# !python3 divisive_clustering_src/main_divisive_clustering.py --target qpp-cpu --M 25" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "N=25 can still easily be completed by a single GPU." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using BFL2 method to generate coresets\n", + "100%|█████████████████████████████████████| 7352/7352 [00:03<00:00, 2063.82it/s]\n", + "100%|███████████████████████████████████| 16492/16492 [00:03<00:00, 4739.44it/s]\n", + "100%|██████████████████████████████████████| 256/256 [00:00<00:00, 15185.58it/s]\n", + "100%|████████████████████████████████████████| 64/64 [00:00<00:00, 23728.05it/s]\n", + "100%|██████████████████████████████████████| 256/256 [00:00<00:00, 15437.97it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 50840.05it/s]\n", + "100%|████████████████████████████████████████| 32/32 [00:00<00:00, 33562.82it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 54120.05it/s]\n", + "100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 54560.05it/s]\n", + "100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 55924.05it/s]\n", + "100%|████████████████████████████████████████| 16/16 [00:00<00:00, 42717.29it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 55007.27it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 53601.33it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 47127.01it/s]\n", + "Total time for the execution: 67.61674502899999\n", + "Total time spent on CUDA-Q: 21.439895901\n" + ] + } + ], + "source": [ + "# target = 'nvidia'\n", + "!python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia --M 25" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we want to push the simulation to an $N=34$ coreset, a single GPU (assuming A100) will run out of memory. Run the code below to see for yourself. " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using BFL2 method to generate coresets\n", + "RuntimeError: NLOpt runtime error: nlopt failure\n" + ] + } + ], + "source": [ + "# target = 'nvidia'\n", + "!python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia --M 34" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To compute a problem with 34 qubits, we need to pool the memory of multiple GPUs. If you have multiple GPUs available, try the code below to run the same computation on 4 GPUs. You do not need to wait for the code to finish, just note how it does not fail immediately due to memory issues." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using BFL2 method to generate coresets\n", + "Using BFL2 method to generate coresets\n", + "Using BFL2 method to generate coresets\n", + "Using BFL2 method to generate coresets\n", + "^C\n" + ] + } + ], + "source": [ + "# target = 'nvidia-mgpu'\n", + "gpu_count = !nvidia-smi -L | wc -l\n", + "try:\n", + " gpu_count = int(gpu_count[0])\n", + "except:\n", + " gpu_count = 0 \n", + "if gpu_count >= 4:\n", + " !mpirun -np 4 python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia-mgpu --M 34\n", + "else:\n", + " print(f'Not enough GPUs found on this system ({gpu_count}) to run this step')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/pr-2023/_sources/examples/python/tutorials/readout_error_mitigation.ipynb.txt b/pr-2023/_sources/examples/python/tutorials/readout_error_mitigation.ipynb.txt index cec9dea413..1d1fee4095 100644 --- a/pr-2023/_sources/examples/python/tutorials/readout_error_mitigation.ipynb.txt +++ b/pr-2023/_sources/examples/python/tutorials/readout_error_mitigation.ipynb.txt @@ -7,7 +7,7 @@ "source": [ "# Readout Error Mitigation\n", "\n", - "Readout errors are caused by imperfect qubit measurement and are a common source of error in quantum computing. Properly modelling these errors in simulation can give the user tools to understand better how these errors are and how to mitigate them when running on actual quantum devices.\n", + "Readout errors are caused by imperfect qubit measurement and are a common source of error in quantum computing. Properly modelling these errors in simulation can give the user tools to understand better what these errors are and how to mitigate them when running on actual quantum devices.\n", "\n", "Readout errors can be mitigated with a confusion matrix $A$. It is a square matrix of size $2^n \\times 2^n$ and tells about the probability of observing the state $|y\\rangle$ given the true state $|x\\rangle$. The confusion matrix characterizes the readout error of the device and is circuit-independent. Once $A$ is estimated, we can compute its pseudoinverse $A^+$ which can be applied to the noisy probability distribution $p_{\\text{noisy}}$ to obtain an adjusted quasi-probability distribution \n", "\n", @@ -18,7 +18,7 @@ "In this tutorial, we show how to build a confusion matrix with the following approaches.\n", "\n", "- Using a single qubit model\n", - "- using $k$ local confusion matrices\n", + "- Using $k$ local confusion matrices\n", "- A full confusion matrix for each $2^n$ combination\n", "\n", "The last method works well for correcting correlated errors (which affect multiple qubits together). However, it becomes impractical for large numbers of qubits." @@ -73,7 +73,7 @@ "To model the readout error, we apply a bitflip channel on every qubit at the end of the circuit using an Identity gate. The probability of bitflip `probs` can be the same or different for all the qubits.\n", "\n", "
Note: \n", - "In principle, readout error is applied to the measurement gate but we use Identity gate as adding a quantum error on the measurement gate is not yet supported. Also, the Identity gate is not present in the add_channel method, so we model the Identity gate using a rotation gate with an angle of 0.0.\n", + "In principle, readout error is applied to the measurement gate but we use the Identity gate because adding a quantum error on the measurement gate is not yet supported. Also, the Identity gate is not present in the add_channel method, so we model the Identity gate using a rotation gate with an angle of 0.0.\n", "
" ] }, @@ -114,7 +114,7 @@ "id": "bb4c7a14-1c0c-4fab-a6aa-7174c23baa7f", "metadata": {}, "source": [ - "We define a cudaq kernel which will help create a set of quantum circuits to take measurements of the basis states for $n$ qubits. It takes the number of qubits and the basis state as arguments." + "We define a cudaq kernel which will help create a set of quantum circuits to take measurements of the basis states for $n$ qubits. The kernel takes the number of qubits and the basis state as arguments." ] }, { @@ -141,7 +141,7 @@ "id": "95411463-cd1e-499f-baef-d624acc0122c", "metadata": {}, "source": [ - "For the tutorial, we will use GHZ state on three qubits for testing readout error mitigation. The GHZ state on 3 qubits is described as:\n", + "For the tutorial, we will use the GHZ state on three qubits to test readout error mitigation. The GHZ state on 3 qubits is described as:\n", "\n", "$$\n", "\\frac{|000\\rangle + |111\\rangle}{\\sqrt{2}}\n", @@ -163,7 +163,7 @@ " for i in range(n_qubits - 1):\n", " cx(qvector[i], qvector[i + 1])\n", "\n", - " # Apply id gates for readout error mitigation\n", + " # Apply identity gates for readout error mitigation\n", " for i in range(n_qubits):\n", " rx(0.0, qvector[i])\n", "\n", @@ -199,7 +199,7 @@ "id": "032f6898-c953-4d30-a2bf-e8b46ee77c62", "metadata": {}, "source": [ - "It is possible that the adjusted quasi-probability distribution $p_{\\text{mitigated}}$ obtained by application of $A^+$ to $p_{\\text{noisy}}$ can be possibly non-positive. We need to find the closest positive probability distribution in such a case.\n", + "It is possible that the adjusted quasi-probability distribution $p_{\\text{mitigated}}$ obtained by application of $A^+$ to $p_{\\text{noisy}}$ may be non-positive. We need to find the closest positive probability distribution in such a case.\n", "\n", " $$ p'' = \\min_{p_{\\rm positive}} \\|p_{\\rm noisy} - p_{\\rm positive}\\|_1$$\n", "\n", @@ -393,7 +393,7 @@ "source": [ "## Inverse confusion matrix from single-qubit noise model\n", "\n", - "Here we assume that the readout error of each qubit is independent and with the same confusion probabilities. Then, the confusion matrix $A_1$ for a single qubit can be defined as\n", + "Here we assume that the readout error of each qubit is independent with the same confusion probabilities. Then, the confusion matrix $A_1$ for a single qubit can be defined as\n", "\n", "$$\n", "A_1 = \\begin{bmatrix}\n", @@ -402,7 +402,7 @@ "\\end{bmatrix}\n", "$$\n", "\n", - "where $P(y|x)$ is the probability of observing state $|y\\rangle$ when measuring true state $|x\\rangle$. Using $A_1$ the full $2^n \\times 2^n$ confusion matrix $A$ can be written as \n", + "where $P(y|x)$ is the probability of observing state $|y\\rangle$ when measuring the true state $|x\\rangle$. Using $A_1$, the full $2^n \\times 2^n$ confusion matrix $A$ can be written as \n", "\n", "$$\n", "A = A_1 \\otimes \\dots \\otimes A_1\n", @@ -719,7 +719,7 @@ "source": [ "## Inverse of full confusion matrix\n", "\n", - "Here we generate a quantum circuit for each of the basis states of $n$ qubits i.e. $2^n$ combinations. This gives more accurate readout error mitigation. Since it scales exponentially with the number of qubits, it is only practical for small devices." + "Here we generate a quantum circuit for each of the basis states of $n$ qubits (i.e., $2^n$ combinations). This gives more accurate readout error mitigation. Since it scales exponentially with the number of qubits, it is only practical for small devices." ] }, { diff --git a/pr-2023/_sources/examples/python/tutorials/visualization.ipynb.txt b/pr-2023/_sources/examples/python/tutorials/visualization.ipynb.txt new file mode 100644 index 0000000000..0915f4809d --- /dev/null +++ b/pr-2023/_sources/examples/python/tutorials/visualization.ipynb.txt @@ -0,0 +1,299 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualization\n", + "\n", + "## Qubit Visualization\n", + "\n", + "What are the possible states a qubit can be in and how can we build up a visual cue to help us make sense of quantum states and their evolution?\n", + "\n", + "We know our qubit can have two distinct states: $\\ket{0}$ and $\\ket{1}$. Maybe we need a one-dimensional line whose vertices can\n", + "represent each of the states. We also know that qubits can be in an equal superposition states: $\\ket{+}$ and $\\ket{-}$. This now forces us to extend our 1D line to a 2D Cartesian coordinate system. If you dive deeper you will learn about the existence of states like \n", + "$\\ket{+i}$ and $\\ket{-i}$, this calls for a 3D extension.\n", + "\n", + "It turns out that a sphere is able to depict all the possible states of a single qubit. This is called a Bloch sphere. \n", + "\n", + "\"Bloch\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us try to showcase the functionality to render such a 3D representation with CUDA-Q. \n", + "First, let us define a single-qubit kernel that returns a different state each time. This kernel uses random rotations.\n", + "\n", + "Note: CUDA-Q uses the [QuTiP](https://qutip.org) library to render Bloch spheres. The following code will throw an error if QuTiP is not installed. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# install `qutip` in the current Python kernel. Skip this if `qutip` is already installed.\n", + "# `matplotlib` is required for all visualization tasks.\n", + "# Make sure to restart your kernel if you execute this!\n", + "# In a Jupyter notebook, go to the menu bar > Kernel > Restart Kernel.\n", + "# In VSCode, click on the Restart button in the Jupyter toolbar.\n", + "\n", + "# The '\\' before the '>' operator is so that the shell does not misunderstand\n", + "# the '>' qualifier for the bash pipe operation.\n", + "\n", + "import sys\n", + "\n", + "try:\n", + " import matplotlib.pyplot as plt\n", + " import qutip\n", + "\n", + "except ImportError:\n", + " print(\"Tools not found, installing. Please restart your kernel after this is done.\")\n", + " !{sys.executable} -m pip install qutip\\>=5 matplotlib\\>=3.5\n", + " print(\"\\nNew libraries have been installed. Please restart your kernel!\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import cudaq\n", + "import numpy as np\n", + "\n", + "## Retry the subsequent cells by setting the target to density matrix simulator.\n", + "# cudaq.set_target(\"density-matrix-cpu\")\n", + "\n", + "\n", + "@cudaq.kernel\n", + "def kernel(angles: np.ndarray):\n", + " qubit = cudaq.qubit()\n", + " rz(angles[0], qubit)\n", + " rx(angles[1], qubit)\n", + " rz(angles[2], qubit)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we instantiate a random number generator, so we can get random outputs. We then create 4 random single-qubit states by using `cudaq.add_to_bloch_sphere()` on the output state obtained from the random kernel." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "rng = np.random.default_rng(seed=11)\n", + "blochSphereList = []\n", + "for _ in range(4):\n", + " angleList = rng.random(3) * 2 * np.pi\n", + " sph = cudaq.add_to_bloch_sphere(cudaq.get_state(kernel, angleList))\n", + " blochSphereList.append(sph)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can display the spheres with `cudaq.show()`. Show the first sphere:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cudaq.show(blochSphereList[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also show multiple Bloch spheres side by side - simply set the `nrows` and `ncols` in the call to `cudaq.show()` accordingly. Make sure to have more spaces than spheres in your list, else it will throw an error! Let us show two spheres in a row:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cudaq.show(blochSphereList[:2], nrows=1, ncols=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can show them in a column too, if we want! Simply set the `nrows = 2` and `ncols = 1`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cudaq.show(blochSphereList[:2], nrows=2, ncols=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Can we show the entire list of 4 Bloch spheres we created? Absolutely!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cudaq.show(blochSphereList[:], nrows=2, ncols=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What if we had to add multiple vectors to a single Bloch sphere? CUDA-Q uses the [QuTiP](https://www.qutip.org) toolbox to construct Bloch spheres. We can then add multiple states to the same Bloch sphere by passing the sphere object as an argument to `cudaq.add_to_bloch_sphere()`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import qutip\n", + "\n", + "rng = np.random.default_rng(seed=47)\n", + "blochSphere = qutip.Bloch()\n", + "for _ in range(10):\n", + " angleList = rng.random(3) * 2 * np.pi\n", + " sph = cudaq.add_to_bloch_sphere(cudaq.get_state(kernel, angleList), blochSphere)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This created a single Bloch sphere with 10 random vectors. Let us see how it looks." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "blochSphere.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Unfortunately, there is no such handy visualization for multi-qubit states. In particular, a multi-qubit state cannot be visualized as multiple Bloch spheres due to the nature of entanglement that makes quantum computing so powerful. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Kernel Visualization\n", + "\n", + "A CUDA-Q kernel can be visualized using the `cudaq.draw` API which returns a string representing the drawing of the execution path, in the specified format. ASCII (default) and LaTeX formats are supported." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "@cudaq.kernel\n", + "def kernel_to_draw():\n", + " q = cudaq.qvector(4)\n", + " h(q)\n", + " x.ctrl(q[0], q[1])\n", + " y.ctrl([q[0], q[1]], q[2])\n", + " z(q[2])\n", + " \n", + " swap(q[0], q[1])\n", + " swap(q[0], q[3])\n", + " swap(q[1], q[2])\n", + "\n", + " r1(3.14159, q[0])\n", + " tdg(q[1])\n", + " s(q[2])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(cudaq.draw(kernel_to_draw))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(cudaq.draw('latex', kernel_to_draw))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Copy this output string into any LaTeX editor and export it to PDF.\n", + "\n", + "\"Circuit" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "vscode": { + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/pr-2023/_sources/releases.rst.txt b/pr-2023/_sources/releases.rst.txt index e9ac3adfad..6a8a353462 100644 --- a/pr-2023/_sources/releases.rst.txt +++ b/pr-2023/_sources/releases.rst.txt @@ -10,6 +10,37 @@ The latest version of CUDA-Q is on the main branch of our `GitHub repository `__ - `Examples `__ +**0.8.0** + +The 0.8.0 release adds a range of changes to improve the ease of use and performance with CUDA-Q. +The changes listed below highlight some of what we think will be the most useful features and changes +to know about. While the listed changes do not capture all of the great contributions, we would like +to extend many thanks for every contribution, in particular those from external contributors. + +- `Docker image `__ +- `Python wheel `__ +- `C++ installer `__ +- `Documentation `__ +- `Examples `__ + +The full change log can be found `here `__. + +**0.7.1** + +The 0.7.1 release adds simulator optimizations with significant performance improvements and +extends their functionalities. The `nvidia-mgpu` backend now supports user customization of the +gate fusion level as controlled by the `CUDAQ_MGPU_FUSE` environment variable documented +`here `__. +It furthermore adds a range of bug fixes and changes the Python wheel installation instructions. + +- `Docker image `__ +- `Python wheel `__ +- `C++ installer `__ +- `Documentation `__ +- `Examples `__ + +The full change log can be found `here `__. + **0.7.0** The 0.7.0 release adds support for using :doc:`NVIDIA Quantum Cloud `, @@ -19,13 +50,13 @@ Check out our `documentation `__ to learn more about the new setup and its performance benefits. -- `Docker image `__ -- `Python wheel `__ -- `C++ installer `__ +- `Docker image `__ +- `Python wheel `__ +- `C++ installer `__ - `Documentation `__ - `Examples `__ -The full change log can be found `here `__. +The full change log can be found `here `__. **0.6.0** diff --git a/pr-2023/_sources/using/backends/platform.rst.txt b/pr-2023/_sources/using/backends/platform.rst.txt index e2d3604300..18753617c9 100644 --- a/pr-2023/_sources/using/backends/platform.rst.txt +++ b/pr-2023/_sources/using/backends/platform.rst.txt @@ -49,7 +49,8 @@ Here is a simple example demonstrating its usage. ./a.out CUDA-Q exposes asynchronous versions of the default :code:`cudaq` algorithmic -primitive functions like :code:`sample` and :code:`observe` (e.g., :code:`sample_async` function in the above code snippets). +primitive functions like :code:`sample`, :code:`observe`, and :code:`get_state` +(e.g., :code:`sample_async` function in the above code snippets). Depending on the number of GPUs available on the system, the :code:`nvidia` multi-QPU platform will create the same number of virtual QPU instances. For example, on a system with 4 GPUs, the above code will distribute the four sampling tasks among those :code:`GPUEmulatedQPU` instances. @@ -70,6 +71,30 @@ The results might look like the following 4 different random samplings: To specify the number QPUs to be instantiated, one can set the :code:`CUDAQ_MQPU_NGPUS` environment variable. For example, use :code:`export CUDAQ_MQPU_NGPUS=2` to specify that only 2 QPUs (GPUs) are needed. +Since the underlying :code:`GPUEmulatedQPU` is a simulator backend, we can also retrieve the state vector from each +QPU via the :code:`cudaq::get_state_async` (C++) or :code:`cudaq.get_state_async` (Python) as shown in the bellow code snippets. + +.. tab:: Python + + .. literalinclude:: ../../snippets/python/using/cudaq/platform/get_state_async.py + :language: python + :start-after: [Begin Documentation] + +.. tab:: C++ + + .. literalinclude:: ../../snippets/cpp/using/cudaq/platform/get_state_async.cpp + :language: cpp + :start-after: [Begin Documentation] + :end-before: [End Documentation] + + + One can specify the target multi-QPU architecture with the :code:`--target` flag: + + .. code-block:: console + + nvq++ get_state_async.cpp --target nvidia --target-option mqpu + ./a.out + .. deprecated:: 0.8 The :code:`nvidia-mqpu` and :code:`nvidia-mqpu-fp64` targets, which are equivalent to the multi-QPU options `mgpu,fp32` and `mgpu,fp64`, respectively, of the :code:`nvidia` target, are deprecated and will be removed in a future release. @@ -270,3 +295,47 @@ language constructs within quantum kernels may not yet be fully supported. For CUDA-Q kernels that return a value, the remote platform supports returning simple data types of `bool`, integral (e.g., `int` or `std::size_t`), and floating-point types (`float` or `double`) when MLIR-based compilation is enabled (:code:`--enable-mlir`). + +Accessing Simulated Quantum State +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The remote `MQPU` platform supports accessing simulator backend's state vector via the +`cudaq::get_state` (C++) or `cudaq.get_state` (Python) APIs, similar to local simulator backends. + +State data can be retrieved as a full state vector or as individual basis states' amplitudes. +The later is designed for large quantum states, which incurred data transfer overheads. + +.. tab:: Python + + .. code:: python + + state = cudaq.get_state(kernel) + amplitudes = state.amplitudes(['0000', '1111']) + +.. tab:: C++ + + .. code-block:: cpp + + auto state = cudaq::get_state(kernel) + auto amplitudes = state.amplitudes({{0, 0, 0, 0}, {1, 1, 1, 1}}); + +In the above example, the amplitudes of the two requested states are returned. + +For C++ quantum kernels [*]_ compiled with the CUDA-Q MLIR-based compiler and Python kernels, +state accessor is evaluated in a just-in-time/on-demand manner, and hence can be customize to +users' need. + +For instance, in the above amplitude access example, if the state vector is very large, e.g., +multi-GPU distributed state vectors or tensor-network encoded quantum states, the full state vector +will not be retrieved when `get_state` is called. Instead, when the `amplitudes` accessor is called, +a specific amplitude calculation request will be sent to the server. +Thus, only the amplitudes of those basis states will be computed and returned. + +Similarly, for state overlap calculation, if deferred state evaluation is available (Python/MLIR-based compiler) +for both of the operand quantum states, a custom overlap calculation request will be constructed and sent to the server. +Only the final overlap result will be returned, thereby eliminating back-and-forth state data transfers. + +.. [*] Only C++ quantum kernels whose names are available via run-time type information (RTTI) are supported. + For example, quantum kernels expressed as named `struct` are supported but not standalone functions. + Kernels that do not have deferred state evaluation support will perform synchronous `get_state`, whereby the full state + vector is returned from the server immediately. diff --git a/pr-2023/_sources/using/examples/examples.rst.txt b/pr-2023/_sources/using/examples/examples.rst.txt index 2ae41ca6fa..2c35b360a3 100644 --- a/pr-2023/_sources/using/examples/examples.rst.txt +++ b/pr-2023/_sources/using/examples/examples.rst.txt @@ -9,6 +9,7 @@ Examples that illustrate how to use CUDA-Q for application development are avail Introduction Quantum Operations + Visualization <../../examples/python/tutorials/visualization.ipynb> Computing Expectation Values Multi-Control Synthesis Multi-GPU Workflows diff --git a/pr-2023/_sources/using/examples/quantum_operations.rst.txt b/pr-2023/_sources/using/examples/quantum_operations.rst.txt index 28c186af42..5e70e9b4f1 100644 --- a/pr-2023/_sources/using/examples/quantum_operations.rst.txt +++ b/pr-2023/_sources/using/examples/quantum_operations.rst.txt @@ -173,30 +173,3 @@ where the probability of measuring :math:`x = 00, 01, 10, 11` occurs with probability :math:`\lvert \alpha_{x} \rvert ^2` with the normalization condition that :math:`\sum_{x \in \{ 0,1 \}^2} \lvert \alpha_{x} \rvert ^2 = 1`. - - -State Visualization ------------------------------ - -What are the possible states a qubit can be in and how can we build up -a visual cue to help us make sense of quantum states and their -evolution? - -We know our qubit can have two distinct states: :math:`\ket{0}` and -:math:`\ket{1}`. Maybe we need a one-dimensional line whose vertices can -represent each of the aforementioned states. -We also know that qubits can be in an equal superposition states: -:math:`\ket{+}` and :math:`\ket{-}`. This now forces us to extend our -1D line to a 2D Cartesian coordinate system. -If you dive deeper you will learn about the existence of states like -:math:`\ket{+i}` and :math:`\ket{-i}`, this calls for a 3D -extension. - -It turns out that a sphere is able to depict all the possible states of -a single qubit. This is called a Bloch sphere. - -Unfortunately, there is no such handy visualization for multi-qubit states. -In particular, a multi-qubit state cannot be visualized as multiple Bloch -spheres due to the nature of entanglement that makes quantum computing so powerful. - - diff --git a/pr-2023/_sources/using/install/data_center_install.rst.txt b/pr-2023/_sources/using/install/data_center_install.rst.txt index 0100e352b3..f65d1ac7bf 100644 --- a/pr-2023/_sources/using/install/data_center_install.rst.txt +++ b/pr-2023/_sources/using/install/data_center_install.rst.txt @@ -14,13 +14,16 @@ on how to do that. Our installation guide also contains instructions for how to :ref:`connect an IDE ` to a running container. If you do not want use a container runtime, we also provide pre-built binaries -for using CUDA-Q with C++. These binaries are built following the instructions +for using CUDA-Q with C++, and Python wheels for using CUDA-Q with Python. +These binaries and wheels are built following the instructions in this guide and should work for you as long as your system meets the compatibility requirements listed under :ref:`Prerequisites `. -To install them, please follow the instructions :ref:`here `. +To install the pre-built binaries, please follow the instructions +:ref:`here `. To install the Python wheels, please +follow the instructions :ref:`here `. -If our pre-built packages are not a good option for you, e.g. because you would -like to use CUDA-Q on an operating system that is not officially supported, +If your system is not listed as supported by our official packages, e.g. because you would +like to use CUDA-Q on an operating system that uses an older C standard library, please follow this guide carefully without skipping any steps to build and install CUDA-Q from source. The rest of this guide details system requirements during the build and after installation, and walks through the installation steps. @@ -145,10 +148,12 @@ CUDA ~~~~~~~~~~ Building CUDA-Q requires a full installation of the CUDA toolkit. +**You can install the CUDA toolkit and use the CUDA compiler without having a GPU.** The instructions are tested using version 11.8, but any CUDA 11 or 12 version -should work, as long as the installed driver on the host +should work, as long as the CUDA runtime version on the host system matches the +CUDA version used for the build, and the installed driver on the host system supports that CUDA version. We recommend using the latest CUDA version -that is supported by your driver. +that is supported by the driver on the host system. Download a suitable `CUDA version `__ following the installation guide for your platform in the online documentation @@ -166,13 +171,10 @@ install CUDA 11.8: Toolchain ~~~~~~~~~~ -The compiler toolchain used for the build needs to support C++20 and must be a supported +The compiler toolchain used for the build must be a supported `CUDA host compiler `__ for the installed CUDA version. -The following instructions have been tested with -`GCC-11 `__ as your toolchain for building CUDA-Q. -If you use a different compiler, we recommend using an OpenMP-enabled compiler. At this -time, we actively test building with GCC 11 and 12, as well as with Clang 16. +The following instructions have been tested with `GCC-11 `__. Other toolchains may be supported but have not been tested. Within the tested AlmaLinux 8 environment, for example, the following commands @@ -194,12 +196,9 @@ environment variables to point to the respective compilers on your build system: :end-before: [CUDAQuantumCppBuild] - :end-before: [`__. To do so, download the -`makeself script(s) `__ and move the necessary -files to install into a separate folder using the command - -.. literalinclude:: ../../../../docker/release/installer.Dockerfile - :language: bash - :dedent: - :start-after: [>CUDAQuantumAssets] - :end-before: [`__ that can then easily be installed using `pip`. To ensure the wheel can be installed on the host system, make sure to use the same Python version for the build as the one that is installed on the host system. -To build the CUDA-Q Python wheel, you will need to install the following additional +To build a CUDA-Q Python wheel, you will need to install the following additional Python-specific tools: - Python development headers: The development headers for your Python version are installed @@ -327,19 +289,59 @@ installed on any `compatible platform CUDAQuantumCppBuild] + :end-before: [`__. To do so, download the +`makeself script(s) `__ and move the necessary +files to install into a separate folder using the command + +.. literalinclude:: ../../../../docker/release/installer.Dockerfile + :language: bash + :dedent: + :start-after: [>CUDAQuantumAssets] + :end-before: [`__ - is installed and discoverable on your host system. - CUDA-Q supports the GNU C++ standard library (`libstdc++`), - version 11 or newer. Other libraries may work but can cause issues in certain cases. - To use CUDA-Q with Python, you should have a working Python installation on the host system, including the `pip` package manager. +- To use CUDA-Q with C++, you should make sure that you have the necessary development + headers of the C standard library installed. You can check this by searching for + `features.h`, commonly found in `/usr/include/`. You can install the necessary headers + via package manager (usually the package name is called something like `glibc-devel` + or `libc6-devel`). These headers are also included with any installation of GCC. + +To use CUDA-Q with Python, you should have a working +Python installation on the host system, including the `pip` package manager. If you followed the instructions for building the :ref:`CUDA-Q Python wheel `, @@ -377,21 +379,25 @@ the `/etc/profile` file: . /opt/nvidia/cudaq/set_env.sh fi -.. note:: - - CUDA-Q includes its own linker, specifically the `LLD `__ - linker. You can customize which linker the `nvq++` compiler uses by setting the - `NVQPP_LD_PATH` environment variable; for example `export NVQPP_LD_PATH=ld`. +.. note:: + CUDA-Q as built following the instructions above includes and uses the LLVM + C++ standard library. This will not interfere with any other C++ standard library + you may have on your system. Pre-built external libraries, you may want to use with + CUDA-Q, such as specific optimizers for example, have a C API to ensure compatibility + across different versions of the C++ standard library and will work with CUDA-Q without + issues. The same is true for all distributed CUDA libraries. To build you own CUDA + libraries that can be used with CUDA-Q, please take a look at :doc:`../integration/cuda_gpu`. The remaining sections in this document list additional runtime dependencies that are not included in the migrated assets and are needed to use some of the CUDA-Q features and components. CUDA Runtime Libraries -~~~~~~~~~~~~~~~~~~~~~~~ +~~~~~~~~~~~~~~~~~~~~~~~~~~~ To use GPU-acceleration in CUDA-Q you will need to install the necessary -CUDA runtime libraries. While not necessary, we recommend installing +CUDA runtime libraries. Their version (at least the version major) needs to match the version +used for the build. While not necessary, we recommend installing the complete CUDA toolkit like you did for the CUDA-Q build. If you prefer to only install the minimal set of runtime libraries, the following commands, for example, install the necessary packages for the AlmaLinux 8 environment: diff --git a/pr-2023/_sources/using/install/local_installation.rst.txt b/pr-2023/_sources/using/install/local_installation.rst.txt index e4696f02a4..695dc6de72 100644 --- a/pr-2023/_sources/using/install/local_installation.rst.txt +++ b/pr-2023/_sources/using/install/local_installation.rst.txt @@ -251,13 +251,15 @@ To install CUDA-Q, execute the command .. note:: - To use GPU-accelerated backends, you will need to install the necessary CUDA runtime libraries. For more information see the corresponding section on :ref:`Additional CUDA Tools `. + To use GPU-accelerated backends, you will need to install the necessary CUDA runtime libraries. + For more information see the corresponding section on + :ref:`Additional CUDA Tools `. The installation ensures that the necessary environment variables for using the CUDA-Q toolchain are set upon login for all POSIX shells. Confirm that the `nvq++` command is found. If it is not, please make sure to set the environment variables defined by the `set_env.sh` script in the -CUDA-Q installation folder (usually `/opt/nvidia/cudaq`). +CUDA-Q installation folder (usually `/usr/local/cudaq` or `/opt/nvidia/cudaq`). If an MPI installation is available in the directory defined by `MPI_PATH`, the installer automatically enables MPI support in CUDA-Q. @@ -272,18 +274,15 @@ executing the commands MPI_PATH=/usr/local/openmpi # update this path as needed bash "${CUDA_QUANTUM_PATH}/distributed_interfaces/activate_custom_mpi.sh" -.. _local-development-with-vscode: +.. note:: -To develop C++ code, you most likely also want to install the -`C++ standard library `__. -CUDA-Q supports the GNU C++ standard library (`libstdc++`), -version 11 or newer. Other libraries may work but can cause issues in certain cases. -The C++ standard library, including development headers, is almost certainly -available via the package manager for your system. To ensure the libraries and headers -are discoverable, the easiest option is usually to install the complete GCC toolchain. -Note that for certain distributions, you may need to manually enable that version -after installation by running a script called `enable`. You can search for such a -script with the command `find / -path '*gcc*' -name enable`. + Please make sure that you have the necessary development headers of the C standard + library installed. You can check this by searching for `features.h`, commonly found + in `/usr/include/`. You can install the necessary headers via package manager + (usually the package name is called something like `glibc-devel` or `libc6-dev`). + These headers are also included with any installation of GCC. + +.. _local-development-with-vscode: Development with VS Code ------------------------------------ @@ -687,7 +686,7 @@ Installing Pre-built Binaries ++++++++++++++++++++++++++++++++++++ If you installed pre-built binaries for CUDA-Q, you will need to install -the necessary CUDA runtime libraries to use GPU-acceleration in CUDA-Q. +the necessary CUDA 11 runtime libraries to use GPU-acceleration in CUDA-Q. If you prefer to only install the minimal set of runtime libraries, the following commands, for example, install the necessary packages for RHEL 8: @@ -698,8 +697,8 @@ commands, for example, install the necessary packages for RHEL 8: :end-before: [`__. -Please make sure to install CUDA version 11.8 or newer, and confirm that your +linked for that `CUDA version `__. +Please make sure to install CUDA version 11.8, and confirm that your `GPU driver `__ supports that version. While the above packages are sufficient to use GPU-acceleration within CUDA-Q, we recommend installing the complete CUDA toolkit (`cuda-toolkit-11-8`) that also diff --git a/pr-2023/_sources/using/integration/cuda_gpu.rst.txt b/pr-2023/_sources/using/integration/cuda_gpu.rst.txt index 0f64acac62..4ad7c09f89 100644 --- a/pr-2023/_sources/using/integration/cuda_gpu.rst.txt +++ b/pr-2023/_sources/using/integration/cuda_gpu.rst.txt @@ -7,39 +7,107 @@ both the CUDA Toolkit and CUDA-Q tools. More about programming GPUs in CUDA can be found in the `Quick Start Guide `__. -Once the :code:`nvcc` compiler is installed, it is possible to write +Once the `nvcc` compiler is installed, it is possible to write CUDA kernels and have them execute on the system GPU. See NVIDIA's `An Easy Introduction to CUDA C and C++ `__ for more information on getting started with CUDA. CUDA code uses a unique syntax and is, typically, saved in a file with -the extension :code:`.cu`. For our example, assume we have written our -CUDA code in the file :code:`my_proj.cu`. +the extension `.cu`. For our example, assume we have written our +CUDA code in the file `my_proj.cu`. CUDA-Q code is a library-based extension of C++ and uses standard conforming C++ syntax. Typically, a quantum kernel would be -saved in a file with the :code:`.cpp` extension. Again for our +saved in a file with the `.cpp` extension. Again for our example, let's assume that we've written quantum kernels and saved -them in the file :code:`my_proj_quantum.cpp`. +them in the file `my_proj_quantum.cpp`. -There is a bit of a wrinkle to be aware of before we compile these two -compilation units. Version 11 (and earlier) of CUDA :code:`nvcc` -supports the C++ 11, 14, and 17 standards and the default standard is -determined by the host C++ compiler. The CUDA-Q compiler, -:code:`nvq++`, defaults to the C++ 20 standard. To get around this -limitation, the project makefiles should select a common C++ standard -version. Fortunately, :code:`nvq++` does allow the use of C++ 17. +By default, CUDA-Q uses C++ 20 and builds source code against the +LLVM C++ standard library (`libc++`). To create a CUDA library that +can link against CUDA-Q code, make sure to define an API that does +not rely on C++ data structures that rely on a specific C++ toolchain +for all functions intended to be called from CUDA-Q (see also +:ref:`clike-shim`). For example, if you define a CUDA kernel in `my_proj.cu` -Note that starting with version 12 of the CUDA toolkit, the C++ 20 -standard is supported. +.. code-block:: cpp -Our project can then be built with commands such as + template + __global__ void cudaSetFirstNElements(CudaDataType *sv, const CudaDataType *__restrict__ sv2, int64_t N) { + int64_t i = static_cast(blockIdx.x) * blockDim.x + threadIdx.x; + if (i < N) { + sv[i].x = sv2[i].x; + sv[i].y = sv2[i].y; + } else { + sv[i].x = 0.0; + sv[i].y = 0.0; + } + } -.. code:: bash +define the following template and all desired template specializations - nvcc -c -std=c++17 my_proj.cu -o my_proj.o - nvq++ -std=c++17 my_project_quantum.cpp my_proj.o -L ${CUDA_INSTALL}/lib64 -lcudart -o my_executable +.. code-block:: cpp + + template + void setFirstNElements(uint32_t n_blocks, + int32_t threads_per_block, + void *newDeviceStateVector, + void *deviceStateVector, + std::size_t previousStateDimension) { + cudaSetFirstNElements<<>>( + reinterpret_cast(newDeviceStateVector), + reinterpret_cast(deviceStateVector), + previousStateDimension); + } + + template void + setFirstNElements(uint32_t n_blocks, + int32_t threads_per_block, + void *newDeviceStateVector, + void *deviceStateVector, + std::size_t previousStateDimension); + + template void + setFirstNElements(uint32_t n_blocks, + int32_t threads_per_block, + void *newDeviceStateVector, + void *deviceStateVector, + std::size_t previousStateDimension); + +Create the corresponding header file `my_proj.h` declaring the `setFirstNElements` +template. You can then call `setFirstNElements` from within `my_proj_quantum.cpp` +by including `my_proj.h`, for example + +.. code-block:: cpp + + #include "cuComplex.h" + #include "cuda_runtime.h" + #include "device_launch_parameters.h" + #include "my_proj.h" + + using namespace my_kernels; // the namespace where you defined setFirstNElements + + int main () { + const uint32_t n_blocks = 10; + const uint32_t threads_per_block = 5; + + void *deviceStateVector; + cudaMalloc((void **)&deviceStateVector, 2 * sizeof(cuDoubleComplex)); + // ... + void *newDeviceStateVector; + cudaMalloc((void **)&newDeviceStateVector, 2 * sizeof(cuDoubleComplex)); + setFirstNElements(n_blocks, threads_per_block, + newDeviceStateVector, deviceStateVector, + 2); + return 0; + } + +To get an executable, compile the code with + +.. code-block:: bash + + nvcc -c -std=c++17 -Xcompiler -fPIC my_proj.cu -o my_proj.o + nvq++ my_proj_quantum.cpp my_proj.o -I"${CUDA_HOME}/include/" -L"${CUDA_HOME}/lib64" -lcudart -o my_executable Above, :code:`nvq++` is used for the link step and will make sure the CUDA-Q runtime libraries are linked correctly to the executable program. diff --git a/pr-2023/_sources/using/integration/integration.rst.txt b/pr-2023/_sources/using/integration/integration.rst.txt index 1c2c26a113..ce6d6ab094 100644 --- a/pr-2023/_sources/using/integration/integration.rst.txt +++ b/pr-2023/_sources/using/integration/integration.rst.txt @@ -4,7 +4,8 @@ Integration with other Software Tools .. toctree:: :maxdepth: 1 - Combining CUDA with CUDA-Q Downstream CMake Integration + Combining CUDA with CUDA-Q + Integrating with Third-Party Libraries Information about customizing or extending the CUDA-Q toolchain can be found in :doc:`../extending/extending`. \ No newline at end of file diff --git a/pr-2023/_sources/using/integration/libraries.rst.txt b/pr-2023/_sources/using/integration/libraries.rst.txt new file mode 100644 index 0000000000..0e7c7c6fcd --- /dev/null +++ b/pr-2023/_sources/using/integration/libraries.rst.txt @@ -0,0 +1,226 @@ +Integrating with Third-Party Libraries +**************************************** + +CUDA-Q enables easily integrating quantum kernels with existing state-of-the-art tools +for classical computing and high performance computing. While quantum kernels are expressed +in Python or C++, quantum hardware backends only support a very limited set of classical +instructions. Correspondingly, only a select set of libraries and functions that are +directly supported by the CUDA-Q compiler can be called from within quantum kernels. +Code that is not marked as kernel code, on the other hand, can be used to invoke the +defined quantum kernels as well as any classical tools and libraries. CUDA-Q provides +a complete toolset to build complex applications running on multi-processor systems involving +CPUs, GPUs and QPUs. + +In Python, integration with any third-party Python package is handled +automatically without any need for additional configuration. For C++, the rest of this +document outlines how to integration with libraries that are compile with a different +compiler than `nvq++`. + + +Calling a CUDA-Q library from C++ +-------------------------------------- + +The CUDA-Q compiler is a fully-featured C++ compiler able to process arbitrary C++ code outside +of quantum kernels. In fact, the CUDA-Q installation includes and invokes a custom-built Clang +compiler under the hood. In general, it hence is not necessary to use a different compiler to +compile C++ host code that calls into quantum kernels; the host code is compiled along with +the quantum kernels into a single library or executable by the CUDA-Q toolchain. + +If you would still like to create a library that can be included in libraries and executables +built with a different toolchain, you can configure `nvq++` to include and encapsulate all its +C++ dependencies, such that the CUDA-Q library only depends on C libraries. For example, +if you have a file `quantum_kernel.cpp` containing + +.. code:: C++ + + #include "cudaq.h" + #include + #include + + namespace quantum { + + __qpu__ void bell() { + cudaq::qvector qs(2); + h(qs[0]); + cnot(qs[0], qs[1]); + mz(qs); + } + + // Usually, one would probably return something like + // the most probably value in the distribution rather + // than the string dump. However, the bell kernel here + // has a 50/50 chance of returning 00 or 11. + const char* bell_distribution() { + auto dist = cudaq::sample(bell); + + std::stringbuf buffer; + std::ostream os(&buffer); + dist.dump(os); + auto sample_results = buffer.str(); + + char* ptr = new char[sample_results.size() + 1]; + strcpy(ptr, sample_results.c_str()); + return ptr; + } + + } // namespace quantum + +you can create such a library with the command + +.. code:: bash + + nvq++ quantum_kernel.cpp -shared -static-libstdc++ -fPIC -o libquantum_kernel.so + +To use this library in a project built with an external toolchain, define a suitable +header file `quantum_kernel.h` containing + +.. code:: C++ + + namespace quantum { + const char* bell_distribution(); + } + +and include it in your project. For example, if `external.cpp` contains + +.. code:: C++ + + #include + #include "quantum_kernel.h" + + int main () { + // some code + auto bell_dist = quantum::bell_distribution(); + std::cout << bell_dist << std::endl; + delete[] bell_dist; + // more code + return 0; + } + +you can compile it with `g++` and link it with the built `libquantum_kernel.so` library +using the command + +.. code:: bash + + g++ external.cpp -lquantum_kernel -L"$(pwd)" -Wl,-rpath="$(pwd)" -I"$(pwd)" + +Note that the API defined in `quantum_kernel.h` does not depend on any data types that +rely on the specific implementation of the C++ standard library. For example, we return a +`const char*` instead of a `std::string` value. This is important to ensure that the data +is handled correctly regardless of which C++ standard library is used. If you include +data types that depend on a specific C++ ABI, the linker should detect this incompatibility +and should generate an error. See the section :ref:`clike-shim` below to learn more about +what to watch out for when defining an API to interface between libraries that are built +with different compilers. + + +Calling an C++ library from CUDA-Q +-------------------------------------- + +CUDA-Q comes with a complete C++ toolchain, and is configured to use its own C++ standard +library by default. When calling a third-party library from within a CUDA-Q application, +the quantum kernels and the surrounding application code are compiled with the `nvq++` compiler, +whereas the third-party library may be compiled with a different toolchain. +For most widely distributed libraries, this will work out of the box. The exception are +third-party libraries that are pre-compiled (opposed to being header-only libraries) +and dynamically depend on a different C++ standard library than CUDA-Q uses. +This is the case for a library `third_party_library.so` if `libstdc++.so` is listed +in the output of the command + +.. code:: bash + + ldd third_party_library.so + +To use such a library with CUDA-Q, you have to install the static version of the +library. The `nvq++` compiler can be configured to link a static library +`libexternal_library.a` instead of the shared one with the same flags as GCC/Clang: + +.. code:: bash + + nvq++ my_code.cpp -Wl,-Bstatic -lexternal_library -Wl,-Bdynamic ... + +If the compilation fails due to undefined symbols during linking, then `libexternal_library.a` +does not include the C++ standard library components it depends on. In this case, you can create a +suitable static library that contains the external library as well as its `libstdc++` dependencies +by combining `libexternal_library.a` and `libstdc++.a` into a single flattened archive. +For example, if the external library is built with GCC and located in `/usr/lib`, +the following commands create a suitable archive using the GNU archiver: + +.. code:: bash + + ar cruT libexternal_library_complete.a /usr/lib/libexternal_library.a "$(g++ -print-file-name=libstdc++.a)" + echo -e 'create libexternal_library_complete.a\naddlib libexternal_library_complete.a\nsave\nend' | ar -M + +The above commands create a new static library `libexternal_library_complete.a` in the current directory. +To use it, adjust the `nvq++` command accordingly: + +.. code:: bash + + nvq++ my_code.cpp -L. -Wl,-Bstatic -lexternal_library_complete -Wl,-Bdynamic ... + +.. note:: + + If the third-party library functions you are calling from your CUDA-Q code + consume or produce data types that explicitly depend on the C++ standard library implementation, + a small shim is needed to properly encapsulate these dependencies, as described in + :ref:`clike-shim`. + + +.. _clike-shim: + +Interfacing between binaries compiled with a different toolchains +--------------------------------------------------------------------- + +To avoid incompatibilities between different C++ implementations, +two binaries built using a different C++ compiler should be careful when passing data types between them +that rely on a specific C++ implementation. While primitive data types can be passed without +issues, attempting to pass a string, for example, will result in a linking failure; a `char*` must +be passed instead of a string. + +Most other data types, including templated types, can be passed as long as their alignment matches. +While different compilers generally align data differently, it is possible to force a particular +alignment when defining the data type or value. For example, if we define a struct + +.. code:: C++ + + #pragma pack(push, 4) + template + struct Entry { + bool is_integral; + ScalarType value; + }; + #pragma pack(pop) + +the `pragma` directives ensure that each item will be 4-byte aligned, regardless of the +default setting that can differ between compilers. + +Even function pointers can usually be passed, as long as their argument and return types can be passed. +When using templated functions and data types, the header file should only include their declaration as well +as explicit instantiation for all valid template arguments. For example, + +.. code:: C++ + + template + void initializeDeviceStateVector(uint32_t n_blocks, + int32_t threads_per_block, + void *deviceStateVector, + std::size_t stateDimension) { + cudaInitializeDeviceStateVector<<>>( + reinterpret_cast(deviceStateVector), stateDimension); + } + + template void + initializeDeviceStateVector(uint32_t n_blocks, + int32_t threads_per_block, + void *deviceStateVector, + std::size_t stateDimension); + + template void + initializeDeviceStateVector(uint32_t n_blocks, + int32_t threads_per_block, + void *deviceStateVector, + std::size_t stateDimension); + +The most cumbersome aspect when libraries built with different toolchains are combined into a single executable +is exception handling. Since the handling relies on a specific ABI, an thrown exception is not necessarily +recognized as such in a library that uses a different ABI implementation. While matching the exception type +may not work as expected, a catch-all will reliably catch any thrown exception. diff --git a/pr-2023/_sources/using/tutorials.rst.txt b/pr-2023/_sources/using/tutorials.rst.txt index a9fcfe3864..e1ded4b211 100644 --- a/pr-2023/_sources/using/tutorials.rst.txt +++ b/pr-2023/_sources/using/tutorials.rst.txt @@ -17,3 +17,4 @@ Tutorials that give an in depth view of CUDA-Q and its applications in Python. /examples/python/tutorials/noisy_simulations.ipynb /examples/python/tutorials/readout_error_mitigation.ipynb /examples/python/tutorials/vqe_water_active_space.ipynb + /examples/python/tutorials/Divisive_clustering.ipynb diff --git a/pr-2023/api/api.html b/pr-2023/api/api.html index df6d9d1364..f1efff6dc3 100644 --- a/pr-2023/api/api.html +++ b/pr-2023/api/api.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/api/default_ops.html b/pr-2023/api/default_ops.html index 810f54d2de..4175b4f054 100644 --- a/pr-2023/api/default_ops.html +++ b/pr-2023/api/default_ops.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • @@ -1052,6 +1072,146 @@

    my< +
    +

    User-Defined Custom Operations

    +

    Users can define a custom quantum operation by its unitary matrix. First use +the API to register a custom operation, outside of a CUDA-Q kernel. Then the +operation can be used within a CUDA-Q kernel like any of the built-in operations +defined above. +Custom operations are supported on qubits only (qudit with level = 2).

    +
    +
    +

    The cudaq.register_operation API accepts an identifier string for +the custom operation and its unitary matrix. The matrix can be a list or +numpy array of complex numbers. A 1D matrix is interpreted as row-major.

    +
    import cudaq
+import numpy as np
+
+cudaq.register_operation("custom_h", 1. / np.sqrt(2.) * np.array([1, 1, 1, -1]))
+
+cudaq.register_operation("custom_x", np.array([0, 1, 1, 0]))
+
+@cudaq.kernel
+def bell():
+    qubits = cudaq.qvector(2)
+    custom_h(qubits[0])
+    custom_x.ctrl(qubits[0], qubits[1])
+
+cudaq.sample(bell).dump()
+
    +
    +
    +
    +

    The macro CUDAQ_REGISTER_OPERATION accepts a unique name for the +operation, the number of target qubits, the number of rotation parameters +(can be 0), and the unitary matrix as a 1D row-major std::vector<complex> +representation.

    +
    #include <cudaq.h>
+
+CUDAQ_REGISTER_OPERATION(custom_h, 1, 0,
+                        {M_SQRT1_2, M_SQRT1_2, M_SQRT1_2, -M_SQRT1_2})
+
+CUDAQ_REGISTER_OPERATION(custom_x, 1, 0, {0, 1, 1, 0})
+
+__qpu__ void bell_pair() {
+    cudaq::qubit q, r;
+    custom_h(q);
+    custom_x<cudaq::ctrl>(q, r);
+}
+
+int main() {
+    auto counts = cudaq::sample(bell_pair);
+    for (auto &[bits, count] : counts) {
+        printf("%s\n", bits.data());
+    }
+}
+
    +
    +
    +
    +

    For multi-qubit operations, the matrix is interpreted with MSB qubit ordering, +i.e. big-endian convention. The following example shows two different custom +operations, each operating on 2 qubits.

    +
    +
    +
    import cudaq
+import numpy as np
+
+# Create and test a custom CNOT operation.
+cudaq.register_operation("my_cnot", np.array([1, 0, 0, 0,
+                                              0, 1, 0, 0,
+                                              0, 0, 0, 1,
+                                              0, 0, 1, 0]))
+
+@cudaq.kernel
+def bell_pair():
+    qubits = cudaq.qvector(2)
+    h(qubits[0])
+    my_cnot(qubits[0], qubits[1]) # `my_cnot(control, target)`
+
+
+cudaq.sample(bell_pair).dump() # prints { 11:500 00:500 } (exact numbers will be random)
+
+
+# Construct a custom unitary matrix for X on the first qubit and Y
+# on the second qubit.
+X = np.array([[0,  1 ], [1 , 0]])
+Y = np.array([[0, -1j], [1j, 0]])
+XY = np.kron(X, Y)
+
+# Register the custom operation
+cudaq.register_operation("my_XY", XY)
+
+@cudaq.kernel
+def custom_xy_test():
+    qubits = cudaq.qvector(2)
+    my_XY(qubits[0], qubits[1])
+    y(qubits[1]) # undo the prior Y gate on qubit 1
+
+
+cudaq.sample(custom_xy_test).dump() # prints { 10:1000 }
+
    +
    +
    +
    +
    #include <cudaq.h>
+
+CUDAQ_REGISTER_OPERATION(MyCNOT, 2, 0,
+                         {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0});
+
+CUDAQ_REGISTER_OPERATION(
+    MyXY, 2, 0,
+    {0, 0, 0, {0, -1}, 0, 0, {0, 1}, 0, 0, {0, -1}, 0, 0, {0, 1}, 0, 0, 0});
+
+__qpu__ void bell_pair() {
+  cudaq::qubit q, r;
+  h(q);
+  MyCNOT(q, r); // MyCNOT(control, target)
+}
+
+__qpu__ void custom_xy_test() {
+  cudaq::qubit q, r;
+  MyXY(q, r);
+  y(r); // undo the prior Y gate on qubit 1
+}
+
+int main() {
+  auto counts = cudaq::sample(bell_pair);
+  counts.dump(); // prints { 11:500 00:500 } (exact numbers will be random)
+
+  counts = cudaq::sample(custom_xy_test);
+  counts.dump(); // prints { 10:1000 }
+}
+
    +
    +
    +
    +
    +

    Note

    +

    Custom operations are currently supported only on CUDA-Q Simulation Backends. +Attempt to use with a hardware backend will result in runtime error.

    +
    +
    diff --git a/pr-2023/api/languages/cpp_api.html b/pr-2023/api/languages/cpp_api.html index 830b50fae0..d520f09eee 100644 --- a/pr-2023/api/languages/cpp_api.html +++ b/pr-2023/api/languages/cpp_api.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • @@ -2799,7 +2819,7 @@

    Algorithms
    std::complex<double> overlap(const state &other)
    -

    Compute the overlap of this state with the other one.

    +

    Compute the overlap of this state with the other one. For state vectors (pure states), it is computed as |<this | other>|.

    diff --git a/pr-2023/api/languages/python_api.html b/pr-2023/api/languages/python_api.html index 56b0a62785..baa818788d 100644 --- a/pr-2023/api/languages/python_api.html +++ b/pr-2023/api/languages/python_api.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • @@ -2065,7 +2085,7 @@

    Data Typesstatic random()
    -random(qubit_count: int, term_count: int, seed: int = 4097292269) → cudaq.mlir._mlir_libs._quakeDialects.cudaq_runtime.SpinOperator
    +random(qubit_count: int, term_count: int, seed: int = 1183127353) → cudaq.mlir._mlir_libs._quakeDialects.cudaq_runtime.SpinOperator

    Return a random SpinOperator on the given number of qubits (qubit_count) and composed of the given number of terms (term_count). An optional seed value may also be provided.

    diff --git a/pr-2023/examples/python/tutorials/Divisive_clustering.html b/pr-2023/examples/python/tutorials/Divisive_clustering.html new file mode 100644 index 0000000000..9d2bffa55f --- /dev/null +++ b/pr-2023/examples/python/tutorials/Divisive_clustering.html @@ -0,0 +1,1445 @@ + + + + + + + Divisive Clustering With Coresets Using CUDA-Q — NVIDIA CUDA-Q documentation + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + +
    + +
    +
    +
    + +
    +
    +
    +
    + +
    +

    Divisive Clustering With Coresets Using CUDA-Q

    +

    This tutorial will explore a CUDA-Q implementation of recent research (ArXiv Paper: https://arxiv.org/pdf/2402.01529.pdf) performed by a team from the University of Edinburgh. This tutorial was jointly developed by NVIDIA and the authors so users can better understand their method and explore how CUDA-Q removed barriers to scaling.

    +

    The code for this tutorial is based off the MIT licensed code found here: https://github.com/Boniface316/bigdata_vqa

    +

    Clustering is a common unsupervised learning technique aimed at grouping data with similar characteristics. The unique properties of quantum computers could allow for enhanced pattern finding in clustering applications and enable more reliable data analysis. However, quantum computers today are severely limited by qubit count and noise. Performing practical clustering applications would require far too many qubits. The Edinburgh team developed a new method (extending the work of Harrow) to +leverage coresets for clustering applications on quantum computers and use far fewer qubits. This tutorial will walk through an example using this approach for divisive clustering and emphasize the utility of CUDA-Q for scaling quantum simulations.

    +

    The goal of divisive clustering is to begin with all data points as one set, and iteratively bipartition the data until each point is its own cluster. The branching behavior of this process can be used to understand similarities in the data points.

    +
    +
    [1]:
+
    +
    +
    # If you are running outside of a CUDA-Q container or CUDA-Q directory tree, you may need to uncomment these lines to fetch the files.
+# If you are running inside a CUDA-Q tree, then this step can be skipped.
+# !mkdir divisive_clustering_src
+# !wget -P divisive_clustering_src https://raw.githubusercontent.com/NVIDIA/cuda-quantum/main/docs/sphinx/examples/python/tutorials/divisive_clustering_src/divisive_clustering.py
+# !wget -P divisive_clustering_src https://raw.githubusercontent.com/NVIDIA/cuda-quantum/main/docs/sphinx/examples/python/tutorials/divisive_clustering_src/main_divisive_clustering.py
+
    +
    +
    +
    +
    [ ]:
+
    +
    +
    # Install the relevant packages.
+!pip install mpi4py==3.1.6
+!pip install networkx==2.8.8
+!pip install pandas==2.2.2
+!pip install scikit-learn==1.4.2
+!pip install tqdm==4.66.2
+
    +
    +
    +
    +
    [3]:
+
    +
    +
    import cudaq
+from cudaq import spin
+
+
+# Auxillary Imports
+import os
+import numpy as np
+import networkx as nx
+import pandas as pd
+import matplotlib.pyplot as plt
+import warnings
+from typing import Tuple
+from divisive_clustering_src.divisive_clustering import Coreset, DivisiveClustering, Dendrogram, Voironi_Tessalation
+
+warnings.filterwarnings("ignore")
+
    +
    +
    +

    The settings below are global parameters for the quantum simulation and can be toggled by the user.

    +
    +
    [4]:
+
    +
    +
    circuit_depth = 1
+max_iterations = 75
+max_shots = 1000
+
    +
    +
    +

    Given a data set \(X = (x_1, x_2, \cdots, x_N)\), a coreset is weighted data set of much smaller size (\(X', w\)) that represents \(X\) enough such that analysis of (\(X', w\)) can allow us to draw reasonable approximate conclusions about \(X\). There are various approaches to build coresets. They can be found in Practical Coreset Construction for Machine Learning (https://arxiv.org/pdf/1703.06476.pdf) and New Streaming Algorithms for Coresets in Machine Learning +(https://arxiv.org/pdf/1703.06476.pdf).

    +

    Essentially, coreset construction boils down to finding the optimal coreset size and weights given some error tolerance. Given the constraints of a quantum computer, in this work, a coreset size is selected \(a\) \(priori\), and the error is determined for each model.

    +

    The following is an example \(M=10\) coreset constructed from a 1000-point data set and loaded into a pandas data frame. See the image below where the coreset is represented by the black stars, the size of which corresponds to the weights.

    +
    +
    [5]:
+
    +
    +
    raw_data = Coreset.create_dataset(1000)
+coreset = Coreset(
+    raw_data=raw_data,
+    number_of_sampling_for_centroids=10,
+    coreset_size=10,
+    number_of_coresets_to_evaluate=4,
+    coreset_method="BFL2",
+)
+
+
+coreset_vectors, coreset_weights = coreset.get_best_coresets()
+
+coreset_df = pd.DataFrame(
+    {"X": coreset_vectors[:, 0], "Y": coreset_vectors[:, 1], "weights": coreset_weights}
+)
+coreset_df["Name"] = [chr(i + 65) for i in coreset_df.index]
+print(coreset_df)
+
    +
    +
    +
    +
    +
    +
    +
    +Using BFL2 method to generate coresets
+          X         Y     weights Name
+0  7.028364  1.669787  234.230716    A
+1  7.167441  0.354792  101.319288    B
+2  1.022889 -0.921443  125.158339    C
+3  2.706134 -2.636852   13.650774    D
+4  6.998497  0.455847  116.758239    E
+5  7.507918  0.630311  120.727176    F
+6 -2.102508  2.297727   53.294127    G
+7  5.722463  1.400433   77.415840    H
+8 -1.425868  2.341136   42.847985    I
+9  7.985373 -0.063209  240.116237    J
+
    +
    +
    +
    [6]:
+
    +
    +
    plt.scatter(raw_data[:, 0], raw_data[:, 1], label="Raw Data", c="#7eba00")
+plt.scatter(
+    coreset_df["X"],
+    coreset_df["Y"],
+    s=coreset_df["weights"],
+    label="Coreset",
+    color="black",
+    marker="*",
+)
+plt.xlabel("X")
+plt.ylabel("Y")
+plt.title("Raw data and its best 10 coreset using BFL2")
+plt.legend()
+plt.show()
+
    +
    +
    +
    +
    +
    +
    +../../../_images/examples_python_tutorials_Divisive_clustering_11_0.png +
    +
    +
    +

    Data preprocessing

    +

    In order to cluster data on a quantum computer, the task needs to be cast into the form of a binary optimization problem. Each qubit represents a coreset point, and the quantum algorithm determines how to bipartition the coreset points at each iteration of the divisive clustering routine.

    +

    The first step is to convert coreset points into a fully connected graph. The edge weight is calculated by:

    +

    \(e_{ij} = w_iw_jd_{ij}\) where \(d_{ij}\) is the Euclidean distance between points \(i\) and \(j\).

    +

    This process is handled by Coreset.coreset_to_graph(). The function returns a fully connected graph \(G\) with edge weights.

    +
    +
    +

    Quantum functions

    +

    The divisive clustering problem will be implemented on a quantum computer using a variational quantum algorithm (VQA) approach. A VQA takes a Hamiltonian (encoded with the optimization problem) and a parameterized ansatz and evaluates expectation values (quantum computer) that inform updates to the ansatz parameters (classical computer). The graph \(G\) (Code in the “src” file) is used to construct the Hamiltonian, derived specifically for the divisive clustering problem, and motivated by a +max-cut Hamiltonian. The spin.z(i) method in CUDA-Q adds a Pauli Z operation that acts on qubit \(i\) to the Hamiltonian.

    +
    +
    [7]:
+
    +
    +
    def get_K2_Hamiltonian(G: nx.Graph) -> cudaq.SpinOperator:
+    """Returns the K2 Hamiltonian for the given graph G
+
+    Args:
+        G (nx.Graph): Weighted graph
+    """
+    H = 0
+
+    for i, j in G.edges():
+        weight = G[i][j]["weight"]
+        H += weight * (spin.z(i) * spin.z(j))
+
+    return H
+
    +
    +
    +

    The code below constructs a quantum kernel, defining the circuit which will serve as an ansatz. The structure of the circuit is a hardware efficient ansatz consisting of layers of parameterized \(R_Z\) and \(R_Y\) gate acting on each qubit, followed by a linear cascade of CNOT gates, and two more rotation gates.

    +

    The @cudaq.kernel decorator allows us to define a quantum circuit in the new kernel mode syntax which provides performance benefits to JIT compilation.

    +
    +
    [8]:
+
    +
    +
    def get_VQE_circuit(number_of_qubits: int, circuit_depth: int) -> cudaq.Kernel:
+    """Returns the VQE circuit for the given number of qubits and circuit depth
+
+    Args:
+        number_of_qubits (int): Number of qubits
+        circuit_depth (int): Circuit depth
+
+    Returns:
+        cudaq.Kernel: VQE Circuit
+    """
+
+    @cudaq.kernel
+    def kernel(thetas: list[float], number_of_qubits: int, circuit_depth: int):
+        """VQE Circuit
+
+        Args:
+            thetas (list[float]): List of parameters
+            number_of_qubits (int): Number of qubits
+            circuit_depth (int): Circuit depth
+        """
+        qubits = cudaq.qvector(number_of_qubits)
+
+        theta_position = 0
+
+        for i in range(circuit_depth):
+            for j in range(number_of_qubits):
+                ry(thetas[theta_position], qubits[j])
+                rz(thetas[theta_position + 1], qubits[j])
+
+                theta_position += 2
+
+            for j in range(number_of_qubits - 1):
+                cx(qubits[j], qubits[j + 1])
+
+            for j in range(number_of_qubits):
+                ry(thetas[theta_position], qubits[j])
+                rz(thetas[theta_position + 1], qubits[j])
+
+                theta_position += 2
+
+    return kernel
+
    +
    +
    +

    We can visualize the circuit using the cudaq.draw() method. Below, we are drawing the circuit for 5 qubits.

    +
    +
    [9]:
+
    +
    +
    parameter_count = 4 * circuit_depth * 5
+parameters = np.random.rand(parameter_count)
+
+circuit = get_VQE_circuit(5, circuit_depth)
+print(cudaq.draw(circuit, parameters, 5, circuit_depth))
+
    +
    +
    +
    +
    +
    +
    +
    +     ╭────────────╮ ╭────────────╮      ╭────────────╮╭────────────╮»
+q0 : ┤ ry(0.8904) ├─┤ rz(0.7335) ├───●──┤ ry(0.4343) ├┤ rz(0.2236) ├»
+     ├────────────┤ ├────────────┤ ╭─┴─╮╰────────────╯├────────────┤»
+q1 : ┤ ry(0.7937) ├─┤ rz(0.9981) ├─┤ x ├──────●───────┤ ry(0.3945) ├»
+     ├───────────┬╯ ├────────────┤ ╰───╯    ╭─┴─╮     ╰────────────╯»
+q2 : ┤ ry(0.696) ├──┤ rz(0.3352) ├──────────┤ x ├───────────●───────»
+     ├───────────┴╮╭┴────────────┤          ╰───╯         ╭─┴─╮     »
+q3 : ┤ ry(0.6658) ├┤ rz(0.05277) ├────────────────────────┤ x ├─────»
+     ├───────────┬╯├─────────────┴╮                       ╰───╯     »
+q4 : ┤ ry(0.791) ├─┤ rz(0.003569) ├─────────────────────────────────»
+     ╰───────────╯ ╰──────────────╯                                 »
+
+################################################################################
+
+
+─────────────────────────────────────────────
+╭────────────╮
+┤ rz(0.4119) ├───────────────────────────────
+├────────────┤╭────────────╮
+┤ ry(0.3205) ├┤ rz(0.3504) ├─────────────────
+╰────────────╯├────────────┤ ╭────────────╮
+──────●───────┤ ry(0.3913) ├─┤ rz(0.7392) ├──
+    ╭─┴─╮     ├────────────┤╭┴────────────┴─╮
+────┤ x ├─────┤ ry(0.3171) ├┤ rz(0.0008056) ├
+    ╰───╯     ╰────────────╯╰───────────────╯
+
+
    +
    +

    The next step is to select a classical optimizer. There are multiple optimizers built-in to CUDA-Q that can be selected. The code below returns the optimizer with the proper number of initial parameters.

    +
    +
    [10]:
+
    +
    +
    def get_optimizer(
+    optimizer: cudaq.optimizers.optimizer, max_iterations, **kwargs
+) -> Tuple[cudaq.optimizers.optimizer, int]:
+    """Returns the optimizer with the given parameters
+
+    Args:
+        optimizer (cudaq.optimizers.optimizer): Optimizer
+        max_iterations (int): Maximum number of iterations
+        **kwargs: Additional arguments
+
+    Returns:
+        tuple(cudaq.optimizers.optimizer, int): Optimizer and parameter count
+    """
+    parameter_count = 4 * kwargs["circuit_depth"] * kwargs["qubits"]
+    initial_params = np.random.uniform(-np.pi / 8.0, np.pi / 8.0, parameter_count)
+    optimizer.initial_parameters = initial_params
+
+    optimizer.max_iterations = max_iterations
+    return optimizer, parameter_count
+
    +
    +
    +
    +
    +

    Divisive Clustering Function

    +

    The DivisiveClusteringVQA class enables the procedure to iteratively bipartition the coreset points until each is its own cluster. If you wish to develop on top of this or see how the underlying code works, please see the divisive_clustering.py file in the src directory.

    +

    run_divisive_clustering, takes the current iteration’s coreset points that will be bipartitioned as inputs, extracts the appropriate weights, and builds a graph \(G\). The graph is then an input into the get_counts_from_simulation function.

    +

    get_counts_from_simulation handles preparation and execution of the quantum simulation. First, it takes \(G\) and from it builds a spin Hamiltonian. Second, it defines a cost function, which in this case is a lambda function that returns the expectation value of our parameterized quantum circuit and the Hamiltonian. This value is obtained using the CUDA-Q observe command, accelerated by GPUs. After the expectation value is minimized, the quantum circuit corresponding to the optimal +parameters is sampled using the CUDA-Q sample function. The bitstrings and their associated counts are returned by get_counts_from_simulation.

    +

    A subset of these counts is evaluated to compute their exact cost. The best bitstring is returned and later used to assign the coreset points to one of two clusters.

    +
    +
    [11]:
+
    +
    +
    class DivisiveClusteringVQA(DivisiveClustering):
+    def __init__(
+        self,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+    def run_divisive_clustering(
+        self,
+        coreset_vectors_df_for_iteration: pd.DataFrame,
+    ):
+        """Runs the Divisive Clustering algorithm
+
+        Args:
+            coreset_vectors_df_for_iteration (pd.DataFrame): Coreset vectors for the iteration
+
+        Returns:
+            str: Best bitstring
+
+        """
+        coreset_vectors_for_iteration_np, coreset_weights_for_iteration_np = (
+            self._get_iteration_coreset_vectors_and_weights(coreset_vectors_df_for_iteration)
+        )
+
+        G = Coreset.coreset_to_graph(
+            coreset_vectors_for_iteration_np,
+            coreset_weights_for_iteration_np,
+            metric=self.coreset_to_graph_metric,
+        )
+
+        counts = self.get_counts_from_simulation(
+            G,
+            self.circuit_depth,
+            self.max_iterations,
+            self.max_shots,
+        )
+
+        return self._get_best_bitstring(counts, G)
+
+    def get_counts_from_simulation(
+        self, G: nx.graph, circuit_depth: int, max_iterations: int, max_shots: int
+    ) -> cudaq.SampleResult:
+        """
+        Runs the VQA simulation
+
+        Args:
+            G (nx.graph): Graph
+            circuit_depth (int): Circuit depth
+            max_iterations (int): Maximum number of iterations
+            max_shots (int): Maximum number of shots
+
+        Returns:
+            cudaq.SampleResult: Measurement from the experiment
+        """
+
+        qubits = len(G.nodes)
+        Hamiltonian = self.create_Hamiltonian(G)
+        optimizer, parameter_count = self.optimizer_function(
+            self.optimizer, max_iterations, qubits=qubits, circuit_depth=circuit_depth
+        )
+
+        kernel = self.create_circuit(qubits, circuit_depth)
+
+        def objective_function(
+            parameter_vector: list[float],
+            hamiltonian: cudaq.SpinOperator = Hamiltonian,
+            kernel: cudaq.Kernel = kernel,
+        ) -> float:
+            """
+
+            Objective function that returns the cost of the simulation
+
+            Args:
+                parameter_vector (List[float]):
+                hamiltonian (cudaq.SpinOperator): Circuit parameter values as a vector
+                kernel (cudaq.Kernel) : Circuit configuration
+
+            Returns:
+                float: Expectation value of the circuit
+
+            """
+
+            get_result = lambda parameter_vector: cudaq.observe(
+                kernel, hamiltonian, parameter_vector, qubits, circuit_depth
+            ).expectation()
+
+            cost = get_result(parameter_vector)
+
+            return cost
+
+        energy, optimal_parameters = optimizer.optimize(
+            dimensions=parameter_count, function=objective_function
+        )
+
+        counts = cudaq.sample(
+            kernel, optimal_parameters, qubits, circuit_depth, shots_count=max_shots
+        )
+
+        return counts
+
    +
    +
    +

    An instance of the DivisiveClusteringVQA class is mostly constructed from variables previously discussed like the functions for building the Hamiltonians and quantum circuits. Parameters related to the quantum simulation can also be specified here such as circuit_depth and max_shots. The threshold_for_max_cut parameter specifies what percent of the sample results from the quantum computer are checked for the best bitstring value.

    +

    The other options specify advanced features like if the data is normalized and how the graph weights are computed.

    +

    Finally, the get_divisive_sequence method performs the iterations and produces the clustering data which we will analyze below. Note that this postprocessing code is not exposed in this tutorial but can be found in the source code.

    +
    +
    [12]:
+
    +
    +
    optimizer = cudaq.optimizers.COBYLA()
+
+divisive_clustering = DivisiveClusteringVQA(
+    circuit_depth=circuit_depth,
+    max_iterations=max_iterations,
+    max_shots=max_shots,
+    threshold_for_max_cut=0.75,
+    create_Hamiltonian=get_K2_Hamiltonian,
+    optimizer=optimizer,
+    optimizer_function=get_optimizer,
+    create_circuit=get_VQE_circuit,
+    normalize_vectors=True,
+    sort_by_descending=True,
+    coreset_to_graph_metric="dist",
+)
+
+hierarchial_clustering_sequence = divisive_clustering.get_divisive_sequence(coreset_df)
+
    +
    +
    +
    +
    +
    +
    +
    +100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 129/129 [00:00<00:00, 12075.19it/s]
+100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 35025.50it/s]
+100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 18/18 [00:00<00:00, 44254.09it/s]
+100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 15827.56it/s]
+100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 13617.87it/s]
+
    +
    +

    The data can be nicely visualized with a Dendrogram which maps where the bipartitionings occurred. Early splits generally mark divisions between the least similar data.

    +
    +
    [13]:
+
    +
    +
    dendo = Dendrogram(coreset_df, hierarchial_clustering_sequence)
+dendo.plot_dendrogram(plot_title="Dendrogram of Coreset using VQE")
+
    +
    +
    +
    +
    +
    +
    +../../../_images/examples_python_tutorials_Divisive_clustering_29_0.png +
    +
    +

    Each branch point in the dendrogram aboves corresponds to one of the plots below. Notice the first iterations are the most complicated, and the final iterations become trivial bipartitioning of two points. Occasionally, especially in the first iteration, the partitioning might be puzzling at first glance. The data might seem to naturally cluster into two groups. However, there are cases where a stray point seems to belong in the wrong cluster. There are two explanations for this. 1) The quantum +sampling is approximate and stochastic. It is possible that too few shots were taken to sample the ground state of the problem. 2) It is important to remember that we are clustering coresets and not data points. There can be cases where it is optimal to pay a penalty by excluding a point based on proximity if the weights are small enough that the penalty has less impact. Usually, if a point looks unusually clustered and you go look at the original coresets plotted above, that point will have a +small weight.

    +
    +
    [14]:
+
    +
    +
    Dendrogram.plot_hierarchial_split(hierarchial_clustering_sequence, coreset_df)
+
    +
    +
    +
    +
    +
    +
    +../../../_images/examples_python_tutorials_Divisive_clustering_31_0.png +
    +
    +

    The hierarchical clustering can be converted to flat clustering by drawing a line perpendicular to the branches. Any data point that intersects the line is considered to be in the same cluster. The function below performs this task at threshold height of 1.5. If you want to use the number of clusters instead of height, you can use dendo.get_clusters_using_k() method. You pass the number of desired clusters as an argument. The figure below shows the clusters that are formed at threshold +height of 1.5.

    +
    +
    [15]:
+
    +
    +
    threshold_height = 1
+clusters = dendo.get_clusters_using_height(threshold_height)
+colors = ["red", "blue", "green", "black", "purple", "orange", "yellow"]
+dendo.plot_dendrogram(
+    plot_title="Dendrogram of Coreset using VQE",
+    colors=colors,
+    clusters=clusters,
+    color_threshold=threshold_height,
+)
+
    +
    +
    +
    +
    +
    +
    +../../../_images/examples_python_tutorials_Divisive_clustering_33_0.png +
    +
    +

    You can visualize the flat clusters using dendo.plot_clusters() method. The function takes the clusters and colors as arguments. The clusters are represented by different colors.

    +
    +
    [16]:
+
    +
    +
    dendo.plot_clusters(
+    clusters, colors, plot_title="Clusters of Coreset using VQE", show_annotation=True
+)
+
    +
    +
    +
    +
    +
    +
    +../../../_images/examples_python_tutorials_Divisive_clustering_35_0.png +
    +
    +

    The function below uses the dendo.get_voronoi_tessalation() method to convert the clusters into regions. coreset_df, clusters and colors need to be passed as the arguments to create the regions. This function creates a region for each coreset point separately and then colors them according to the clusters with colors passed as arguments. Another option is to create regions using the centroids of the clusters. You need to pass tesslation_by_cluster=True to the function to +perform this task.

    +

    Once the region creation is complete, you can use plot_voironi() method to plot the regions. The function takes the clusters and colors as arguments.

    +

    Remembering that these regions were based on coresets, they can overlay the original data set and be used to cluster the data based on the coreset analysis.

    +
    +
    [17]:
+
    +
    +
    vt = Voironi_Tessalation(coreset_df, clusters, colors, tesslation_by_cluster=False)
+vt.plot_voironi(plot_title="Voironi Tessalation of Coreset using VQE", show_annotation=True)
+
    +
    +
    +
    +
    +
    +
    +../../../_images/examples_python_tutorials_Divisive_clustering_37_0.png +
    +
    +
    +
    +

    QAOA Implementation

    +

    CUDA-Q is designed to be a flexible tool for developers so they can test different implementations of the same code. For example, one can perform the same analysis, instead using a QAOA approach. Only the kernel needs to be changed as is done below.

    +
    +
    [18]:
+
    +
    +
    def get_QAOA_circuit(number_of_qubits, circuit_depth) -> cudaq.Kernel:
+    """Returns the QAOA circuit for the given number of qubits and circuit depth
+
+
+    Args:
+        number_of_qubits (int): Number of qubits
+        circuit_depth (int): Circuit depth
+
+    Returns:
+        cudaq.Kernel: QAOA Circuit
+    """
+
+    @cudaq.kernel
+    def kernel(thetas: list[float], number_of_qubits: int, circuit_depth: int):
+        qubits = cudaq.qvector(number_of_qubits)
+
+        layers = circuit_depth
+
+        for layer in range(layers):
+            for qubit in range(number_of_qubits):
+                cx(qubits[qubit], qubits[(qubit + 1) % number_of_qubits])
+                rz(2.0 * thetas[layer], qubits[(qubit + 1) % number_of_qubits])
+                cx(qubits[qubit], qubits[(qubit + 1) % number_of_qubits])
+
+            rx(2.0 * thetas[layer + layers], qubits)
+
+    return kernel
+
+
+circuit = get_QAOA_circuit(5, circuit_depth)
+
+print(cudaq.draw(circuit, np.random.rand(2 * circuit_depth), 5, circuit_depth))
+
    +
    +
    +
    +
    +
    +
    +
    +                                                                             »
+q0 : ──●──────────────────●──────────────────────────────────────────────────»
+     ╭─┴─╮╭────────────╮╭─┴─╮                                                »
+q1 : ┤ x ├┤ rz(0.3527) ├┤ x ├──●──────────────────●──────────────────────────»
+     ╰───╯╰────────────╯╰───╯╭─┴─╮╭────────────╮╭─┴─╮                        »
+q2 : ────────────────────────┤ x ├┤ rz(0.3527) ├┤ x ├──●──────────────────●──»
+                             ╰───╯╰────────────╯╰───╯╭─┴─╮╭────────────╮╭─┴─╮»
+q3 : ────────────────────────────────────────────────┤ x ├┤ rz(0.3527) ├┤ x ├»
+                                                     ╰───╯╰────────────╯╰───╯»
+q4 : ────────────────────────────────────────────────────────────────────────»
+                                                                             »
+
+################################################################################
+
+                        ╭───╮╭────────────╮╭───╮╭───────────╮
+────────────────────────┤ x ├┤ rz(0.3527) ├┤ x ├┤ rx(1.111) ├
+                        ╰─┬─╯╰────────────╯╰─┬─╯├───────────┤
+──────────────────────────┼──────────────────┼──┤ rx(1.111) ├
+                          │                  │  ├───────────┤
+──────────────────────────┼──────────────────┼──┤ rx(1.111) ├
+                          │                  │  ├───────────┤
+──●──────────────────●────┼──────────────────┼──┤ rx(1.111) ├
+╭─┴─╮╭────────────╮╭─┴─╮  │                  │  ├───────────┤
+┤ x ├┤ rz(0.3527) ├┤ x ├──●──────────────────●──┤ rx(1.111) ├
+╰───╯╰────────────╯╰───╯                        ╰───────────╯
+
+
    +
    +
    +
    [19]:
+
    +
    +
    def get_optimizer(
+    optimizer: cudaq.optimizers.optimizer, max_iterations, **kwargs
+) -> Tuple[cudaq.optimizers.optimizer, int]:
+    """
+    Returns the optimizer with the given parameters
+
+    Args:
+        optimizer (cudaq.optimizers.optimizer): Optimizer
+        max_iterations (int): Maximum number of iterations
+        **kwargs: Additional arguments
+
+    Returns:
+        tuple(cudaq.optimizers.optimizer, int): Optimizer and parameter count
+    """
+
+    parameter_count = 2 * kwargs["circuit_depth"]
+    optimizer.initial_parameters = np.random.uniform(-np.pi / 8.0, np.pi / 8.0, parameter_count)
+    optimizer.max_iterations = max_iterations
+    return optimizer, parameter_count
+
    +
    +
    +
    +
    [20]:
+
    +
    +
    optimizer = cudaq.optimizers.COBYLA()
+
+divisive_clustering = DivisiveClusteringVQA(
+    circuit_depth=circuit_depth,
+    max_iterations=max_iterations,
+    max_shots=max_shots,
+    threshold_for_max_cut=0.75,
+    create_Hamiltonian=get_K2_Hamiltonian,
+    optimizer=optimizer,
+    optimizer_function=get_optimizer,
+    create_circuit=get_QAOA_circuit,
+    normalize_vectors=True,
+    sort_by_descending=True,
+    coreset_to_graph_metric="dist",
+)
+
+hierarchial_clustering_sequence = divisive_clustering.get_divisive_sequence(coreset_df)
+
    +
    +
    +
    +
    +
    +
    +
    +100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 484/484 [00:00<00:00, 12163.89it/s]
+100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 52703.30it/s]
+100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 48/48 [00:00<00:00, 31987.07it/s]
+100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 36393.09it/s]
+100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 37957.50it/s]
+100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 42473.96it/s]
+
    +
    +
    +
    +

    Scaling simulations with CUDA-Q

    +

    The University of Edinburgh team quickly encountered scaling challenges when they were developing this method. By developing with CUDA-Q they were able to port their code to an HPC environment once GPUs became available. GPUs massively accelerated their development and testing and allowed them to produce the 25 qubit experiments presented in their publication. If you have a GPU available, run the following code examples and see how the times compare on your device. Each call executes the +divisive clustering procedure using the QAOA method, 100000 simulated shots for each VQE loop, and maximum 75 VQE iterations.

    +

    First, try a slightly larger N=18 problem using the CPU (qpp-cpu) backend.

    +
    +
    [ ]:
+
    +
    +
    # Uncomment the following line if you want to explicitly execute this step on your system.
+# !python3 divisive_clustering_src/main_divisive_clustering.py --target qpp-cpu --M 18
+
    +
    +
    +

    Now try the N=18 example on the GPU backend (nvidia).

    +
    +
    [25]:
+
    +
    +
    !python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia --M 18
+
    +
    +
    +
    +
    +
    +
    +
    +Using BFL2 method to generate coresets
+100%|███████████████████████████████████████| 751/751 [00:00<00:00, 3460.26it/s]
+100%|████████████████████████████████████████| 16/16 [00:00<00:00, 42771.74it/s]
+100%|█████████████████████████████████████| 4064/4064 [00:00<00:00, 6862.37it/s]
+100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 56871.92it/s]
+100%|████████████████████████████████████████| 16/16 [00:00<00:00, 44979.13it/s]
+100%|██████████████████████████████████████| 128/128 [00:00<00:00, 19366.94it/s]
+100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 53773.13it/s]
+100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 54648.91it/s]
+100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 51941.85it/s]
+100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 56111.09it/s]
+Total time for the execution: 461.866833317
+Total time spent on CUDA-Q: 10.452308367999706
+
    +
    +

    Scaling up to N=25, the task becomes even more onerous on a CPU. Depending on your device, the simulation may not even run. Try it and feel free to interrupt after your patience has worn out.

    +
    +
    [ ]:
+
    +
    +
    # target = 'qpp-cpu'
+# Uncomment the following line if you want to explicitly execute this step on your system.
+# !python3 divisive_clustering_src/main_divisive_clustering.py --target qpp-cpu --M 25
+
    +
    +
    +

    N=25 can still easily be completed by a single GPU.

    +
    +
    [27]:
+
    +
    +
    # target = 'nvidia'
+!python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia --M 25
+
    +
    +
    +
    +
    +
    +
    +
    +Using BFL2 method to generate coresets
+100%|█████████████████████████████████████| 7352/7352 [00:03<00:00, 2063.82it/s]
+100%|███████████████████████████████████| 16492/16492 [00:03<00:00, 4739.44it/s]
+100%|██████████████████████████████████████| 256/256 [00:00<00:00, 15185.58it/s]
+100%|████████████████████████████████████████| 64/64 [00:00<00:00, 23728.05it/s]
+100%|██████████████████████████████████████| 256/256 [00:00<00:00, 15437.97it/s]
+100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 50840.05it/s]
+100%|████████████████████████████████████████| 32/32 [00:00<00:00, 33562.82it/s]
+100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 54120.05it/s]
+100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 54560.05it/s]
+100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 55924.05it/s]
+100%|████████████████████████████████████████| 16/16 [00:00<00:00, 42717.29it/s]
+100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 55007.27it/s]
+100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 53601.33it/s]
+100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 47127.01it/s]
+Total time for the execution: 67.61674502899999
+Total time spent on CUDA-Q: 21.439895901
+
    +
    +

    If we want to push the simulation to an \(N=34\) coreset, a single GPU (assuming A100) will run out of memory. Run the code below to see for yourself.

    +
    +
    [28]:
+
    +
    +
    # target = 'nvidia'
+!python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia --M 34
+
    +
    +
    +
    +
    +
    +
    +
    +Using BFL2 method to generate coresets
+RuntimeError: NLOpt runtime error: nlopt failure
+
    +
    +

    To compute a problem with 34 qubits, we need to pool the memory of multiple GPUs. If you have multiple GPUs available, try the code below to run the same computation on 4 GPUs. You do not need to wait for the code to finish, just note how it does not fail immediately due to memory issues.

    +
    +
    [30]:
+
    +
    +
    # target = 'nvidia-mgpu'
+gpu_count = !nvidia-smi -L | wc -l
+try:
+    gpu_count = int(gpu_count[0])
+except:
+    gpu_count = 0
+if gpu_count >= 4:
+    !mpirun -np 4 python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia-mgpu --M 34
+else:
+    print(f'Not enough GPUs found on this system ({gpu_count}) to run this step')
+
    +
    +
    +
    +
    +
    +
    +
    +Using BFL2 method to generate coresets
+Using BFL2 method to generate coresets
+Using BFL2 method to generate coresets
+Using BFL2 method to generate coresets
+^C
+
    +
    +
    +
    [ ]:
+
    +
    +
    
+
    +
    +
    +
    +
    + + +
    +
    + +
    +
    +
    +
    + + + + + + + \ No newline at end of file diff --git a/pr-2023/examples/python/tutorials/Divisive_clustering.ipynb b/pr-2023/examples/python/tutorials/Divisive_clustering.ipynb new file mode 100644 index 0000000000..b3730dcb43 --- /dev/null +++ b/pr-2023/examples/python/tutorials/Divisive_clustering.ipynb @@ -0,0 +1,1088 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Divisive Clustering With Coresets Using CUDA-Q" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This tutorial will explore a CUDA-Q implementation of recent research (ArXiv Paper: https://arxiv.org/pdf/2402.01529.pdf) performed by a team from the University of Edinburgh. This tutorial was jointly developed by NVIDIA and the authors so users can better understand their method and explore how CUDA-Q removed barriers to scaling. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The code for this tutorial is based off the MIT licensed code found here: https://github.com/Boniface316/bigdata_vqa" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Clustering is a common unsupervised learning technique aimed at grouping data with similar characteristics. The unique properties of quantum computers could allow for enhanced pattern finding in clustering applications and enable more reliable data analysis. However, quantum computers today are severely limited by qubit count and noise. Performing practical clustering applications would require far too many qubits. The Edinburgh team developed a new method (extending the work of Harrow) to leverage coresets for clustering applications on quantum computers and use far fewer qubits. This tutorial will walk through an example using this approach for divisive clustering and emphasize the utility of CUDA-Q for scaling quantum simulations.\n", + "\n", + "The goal of divisive clustering is to begin with all data points as one set, and iteratively bipartition the data until each point is its own cluster. The branching behavior of this process can be used to understand similarities in the data points.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# If you are running outside of a CUDA-Q container or CUDA-Q directory tree, you may need to uncomment these lines to fetch the files.\n", + "# If you are running inside a CUDA-Q tree, then this step can be skipped.\n", + "# !mkdir divisive_clustering_src\n", + "# !wget -P divisive_clustering_src https://raw.githubusercontent.com/NVIDIA/cuda-quantum/main/docs/sphinx/examples/python/tutorials/divisive_clustering_src/divisive_clustering.py\n", + "# !wget -P divisive_clustering_src https://raw.githubusercontent.com/NVIDIA/cuda-quantum/main/docs/sphinx/examples/python/tutorials/divisive_clustering_src/main_divisive_clustering.py" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Install the relevant packages.\n", + "!pip install mpi4py==3.1.6\n", + "!pip install networkx==2.8.8\n", + "!pip install pandas==2.2.2\n", + "!pip install scikit-learn==1.4.2\n", + "!pip install tqdm==4.66.2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import cudaq\n", + "from cudaq import spin\n", + "\n", + "\n", + "# Auxillary Imports\n", + "import os\n", + "import numpy as np\n", + "import networkx as nx\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import warnings\n", + "from typing import Tuple\n", + "from divisive_clustering_src.divisive_clustering import Coreset, DivisiveClustering, Dendrogram, Voironi_Tessalation\n", + "\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The settings below are global parameters for the quantum simulation and can be toggled by the user. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "circuit_depth = 1\n", + "max_iterations = 75\n", + "max_shots = 1000" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "Given a data set $X = (x_1, x_2, \\cdots, x_N)$, a coreset is weighted data set of much smaller size ($X', w$) that represents $X$ enough such that analysis of ($X', w$) can allow us to draw reasonable approximate conclusions about $X$. There are various approaches to build coresets. They can be found in Practical Coreset Construction for Machine Learning (https://arxiv.org/pdf/1703.06476.pdf) and New Streaming Algorithms for Coresets in Machine Learning (https://arxiv.org/pdf/1703.06476.pdf).\n", + "\n", + "\n", + "Essentially, coreset construction boils down to finding the optimal coreset size and weights given some error tolerance. Given the constraints of a quantum computer, in this work, a coreset size is selected $a$ $priori$, and the error is determined for each model.\n", + "\n", + "\n", + "The following is an example $M=10$ coreset constructed from a 1000-point data set and loaded into a pandas data frame. See the image below where the coreset is represented by the black stars, the size of which corresponds to the weights.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using BFL2 method to generate coresets\n", + " X Y weights Name\n", + "0 7.028364 1.669787 234.230716 A\n", + "1 7.167441 0.354792 101.319288 B\n", + "2 1.022889 -0.921443 125.158339 C\n", + "3 2.706134 -2.636852 13.650774 D\n", + "4 6.998497 0.455847 116.758239 E\n", + "5 7.507918 0.630311 120.727176 F\n", + "6 -2.102508 2.297727 53.294127 G\n", + "7 5.722463 1.400433 77.415840 H\n", + "8 -1.425868 2.341136 42.847985 I\n", + "9 7.985373 -0.063209 240.116237 J\n" + ] + } + ], + "source": [ + "raw_data = Coreset.create_dataset(1000)\n", + "coreset = Coreset(\n", + " raw_data=raw_data,\n", + " number_of_sampling_for_centroids=10,\n", + " coreset_size=10,\n", + " number_of_coresets_to_evaluate=4,\n", + " coreset_method=\"BFL2\",\n", + ")\n", + "\n", + "\n", + "coreset_vectors, coreset_weights = coreset.get_best_coresets()\n", + "\n", + "coreset_df = pd.DataFrame(\n", + " {\"X\": coreset_vectors[:, 0], \"Y\": coreset_vectors[:, 1], \"weights\": coreset_weights}\n", + ")\n", + "coreset_df[\"Name\"] = [chr(i + 65) for i in coreset_df.index]\n", + "print(coreset_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(raw_data[:, 0], raw_data[:, 1], label=\"Raw Data\", c=\"#7eba00\")\n", + "plt.scatter(\n", + " coreset_df[\"X\"],\n", + " coreset_df[\"Y\"],\n", + " s=coreset_df[\"weights\"],\n", + " label=\"Coreset\",\n", + " color=\"black\",\n", + " marker=\"*\",\n", + ")\n", + "plt.xlabel(\"X\")\n", + "plt.ylabel(\"Y\")\n", + "plt.title(\"Raw data and its best 10 coreset using BFL2\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data preprocessing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to cluster data on a quantum computer, the task needs to be cast into the form of a binary optimization problem. Each qubit represents a coreset point, and the quantum algorithm determines how to bipartition the coreset points at each iteration of the divisive clustering routine. \n", + "\n", + "The first step is to convert coreset points into a fully connected graph. The edge weight is calculated by:\n", + "\n", + "$e_{ij} = w_iw_jd_{ij}$ where $d_{ij}$ is the Euclidean distance between points $i$ and $j$. \n", + "\n", + "This process is handled by `Coreset.coreset_to_graph()`. The function returns a fully connected graph $G$ with edge weights." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quantum functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The divisive clustering problem will be implemented on a quantum computer using a variational quantum algorithm (VQA) approach. A VQA takes a Hamiltonian (encoded with the optimization problem) and a parameterized ansatz and evaluates expectation values (quantum computer) that inform updates to the ansatz parameters (classical computer). The graph $G$ (Code in the \"src\" file) is used to construct the Hamiltonian, derived specifically for the divisive clustering problem, and motivated by a max-cut Hamiltonian. The `spin.z(i)` method in CUDA-Q adds a Pauli Z operation that acts on qubit $i$ to the Hamiltonian." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def get_K2_Hamiltonian(G: nx.Graph) -> cudaq.SpinOperator:\n", + " \"\"\"Returns the K2 Hamiltonian for the given graph G\n", + "\n", + " Args:\n", + " G (nx.Graph): Weighted graph\n", + " \"\"\"\n", + " H = 0\n", + "\n", + " for i, j in G.edges():\n", + " weight = G[i][j][\"weight\"]\n", + " H += weight * (spin.z(i) * spin.z(j))\n", + "\n", + " return H" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The code below constructs a quantum kernel, defining the circuit which will serve as an ansatz. The structure of the circuit is a hardware efficient ansatz consisting of layers of parameterized $R_Z$ and $R_Y$ gate acting on each qubit, followed by a linear cascade of CNOT gates, and two more rotation gates.\n", + "\n", + "The `@cudaq.kernel` decorator allows us to define a quantum circuit in the new kernel mode syntax which provides performance benefits to JIT compilation." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def get_VQE_circuit(number_of_qubits: int, circuit_depth: int) -> cudaq.Kernel:\n", + " \"\"\"Returns the VQE circuit for the given number of qubits and circuit depth\n", + "\n", + " Args:\n", + " number_of_qubits (int): Number of qubits\n", + " circuit_depth (int): Circuit depth\n", + "\n", + " Returns:\n", + " cudaq.Kernel: VQE Circuit\n", + " \"\"\"\n", + "\n", + " @cudaq.kernel\n", + " def kernel(thetas: list[float], number_of_qubits: int, circuit_depth: int):\n", + " \"\"\"VQE Circuit\n", + "\n", + " Args:\n", + " thetas (list[float]): List of parameters\n", + " number_of_qubits (int): Number of qubits\n", + " circuit_depth (int): Circuit depth\n", + " \"\"\"\n", + " qubits = cudaq.qvector(number_of_qubits)\n", + "\n", + " theta_position = 0\n", + "\n", + " for i in range(circuit_depth):\n", + " for j in range(number_of_qubits):\n", + " ry(thetas[theta_position], qubits[j])\n", + " rz(thetas[theta_position + 1], qubits[j])\n", + "\n", + " theta_position += 2\n", + "\n", + " for j in range(number_of_qubits - 1):\n", + " cx(qubits[j], qubits[j + 1])\n", + "\n", + " for j in range(number_of_qubits):\n", + " ry(thetas[theta_position], qubits[j])\n", + " rz(thetas[theta_position + 1], qubits[j])\n", + "\n", + " theta_position += 2\n", + "\n", + " return kernel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can visualize the circuit using the `cudaq.draw()` method. Below, we are drawing the circuit for 5 qubits." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ╭────────────╮ ╭────────────╮ ╭────────────╮╭────────────╮»\n", + "q0 : ┤ ry(0.8904) ├─┤ rz(0.7335) ├───●──┤ ry(0.4343) ├┤ rz(0.2236) ├»\n", + " ├────────────┤ ├────────────┤ ╭─┴─╮╰────────────╯├────────────┤»\n", + "q1 : ┤ ry(0.7937) ├─┤ rz(0.9981) ├─┤ x ├──────●───────┤ ry(0.3945) ├»\n", + " ├───────────┬╯ ├────────────┤ ╰───╯ ╭─┴─╮ ╰────────────╯»\n", + "q2 : ┤ ry(0.696) ├──┤ rz(0.3352) ├──────────┤ x ├───────────●───────»\n", + " ├───────────┴╮╭┴────────────┤ ╰───╯ ╭─┴─╮ »\n", + "q3 : ┤ ry(0.6658) ├┤ rz(0.05277) ├────────────────────────┤ x ├─────»\n", + " ├───────────┬╯├─────────────┴╮ ╰───╯ »\n", + "q4 : ┤ ry(0.791) ├─┤ rz(0.003569) ├─────────────────────────────────»\n", + " ╰───────────╯ ╰──────────────╯ »\n", + "\n", + "################################################################################\n", + "\n", + " \n", + "─────────────────────────────────────────────\n", + "╭────────────╮ \n", + "┤ rz(0.4119) ├───────────────────────────────\n", + "├────────────┤╭────────────╮ \n", + "┤ ry(0.3205) ├┤ rz(0.3504) ├─────────────────\n", + "╰────────────╯├────────────┤ ╭────────────╮ \n", + "──────●───────┤ ry(0.3913) ├─┤ rz(0.7392) ├──\n", + " ╭─┴─╮ ├────────────┤╭┴────────────┴─╮\n", + "────┤ x ├─────┤ ry(0.3171) ├┤ rz(0.0008056) ├\n", + " ╰───╯ ╰────────────╯╰───────────────╯\n", + "\n" + ] + } + ], + "source": [ + "parameter_count = 4 * circuit_depth * 5\n", + "parameters = np.random.rand(parameter_count)\n", + "\n", + "circuit = get_VQE_circuit(5, circuit_depth)\n", + "print(cudaq.draw(circuit, parameters, 5, circuit_depth))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next step is to select a classical optimizer. There are multiple [optimizers](https://nvidia.github.io/cuda-quantum/latest/api/languages/python_api.html#optimizers) built-in to CUDA-Q that can be selected. The code below returns the optimizer with the proper number of initial parameters. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def get_optimizer(\n", + " optimizer: cudaq.optimizers.optimizer, max_iterations, **kwargs\n", + ") -> Tuple[cudaq.optimizers.optimizer, int]:\n", + " \"\"\"Returns the optimizer with the given parameters\n", + "\n", + " Args:\n", + " optimizer (cudaq.optimizers.optimizer): Optimizer\n", + " max_iterations (int): Maximum number of iterations\n", + " **kwargs: Additional arguments\n", + "\n", + " Returns:\n", + " tuple(cudaq.optimizers.optimizer, int): Optimizer and parameter count\n", + " \"\"\"\n", + " parameter_count = 4 * kwargs[\"circuit_depth\"] * kwargs[\"qubits\"]\n", + " initial_params = np.random.uniform(-np.pi / 8.0, np.pi / 8.0, parameter_count)\n", + " optimizer.initial_parameters = initial_params\n", + "\n", + " optimizer.max_iterations = max_iterations\n", + " return optimizer, parameter_count" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Divisive Clustering Function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `DivisiveClusteringVQA` class enables the procedure to iteratively bipartition the coreset points until each is its own cluster. If you wish to develop on top of this or see how the underlying code works, please see the `divisive_clustering.py` file in the src directory. \n", + "\n", + "`run_divisive_clustering`, takes the current iteration's coreset points that will be bipartitioned as inputs, extracts the appropriate weights, and builds a graph $G$. The graph is then an input into the `get_counts_from_simulation` function. \n", + "\n", + "\n", + "`get_counts_from_simulation` handles preparation and execution of the quantum simulation. First, it takes $G$ and from it builds a spin Hamiltonian. Second, it defines a cost function, which in this case is a lambda function that returns the expectation value of our parameterized quantum circuit and the Hamiltonian. This value is obtained using the CUDA-Q `observe` command, accelerated by GPUs. After the expectation value is minimized, the quantum circuit corresponding to the optimal parameters is sampled using the CUDA-Q `sample` function. The bitstrings and their associated counts are returned by `get_counts_from_simulation`.\n", + "\n", + "A subset of these counts is evaluated to compute their exact cost. The best bitstring is returned and later used to assign the coreset points to one of two clusters.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "class DivisiveClusteringVQA(DivisiveClustering):\n", + " def __init__(\n", + " self,\n", + " **kwargs,\n", + " ):\n", + " super().__init__(**kwargs)\n", + "\n", + " def run_divisive_clustering(\n", + " self,\n", + " coreset_vectors_df_for_iteration: pd.DataFrame,\n", + " ):\n", + " \"\"\"Runs the Divisive Clustering algorithm\n", + "\n", + " Args:\n", + " coreset_vectors_df_for_iteration (pd.DataFrame): Coreset vectors for the iteration\n", + "\n", + " Returns:\n", + " str: Best bitstring\n", + "\n", + " \"\"\"\n", + " coreset_vectors_for_iteration_np, coreset_weights_for_iteration_np = (\n", + " self._get_iteration_coreset_vectors_and_weights(coreset_vectors_df_for_iteration)\n", + " )\n", + "\n", + " G = Coreset.coreset_to_graph(\n", + " coreset_vectors_for_iteration_np,\n", + " coreset_weights_for_iteration_np,\n", + " metric=self.coreset_to_graph_metric,\n", + " )\n", + "\n", + " counts = self.get_counts_from_simulation(\n", + " G,\n", + " self.circuit_depth,\n", + " self.max_iterations,\n", + " self.max_shots,\n", + " )\n", + "\n", + " return self._get_best_bitstring(counts, G)\n", + "\n", + " def get_counts_from_simulation(\n", + " self, G: nx.graph, circuit_depth: int, max_iterations: int, max_shots: int\n", + " ) -> cudaq.SampleResult:\n", + " \"\"\"\n", + " Runs the VQA simulation\n", + "\n", + " Args:\n", + " G (nx.graph): Graph\n", + " circuit_depth (int): Circuit depth\n", + " max_iterations (int): Maximum number of iterations\n", + " max_shots (int): Maximum number of shots\n", + "\n", + " Returns:\n", + " cudaq.SampleResult: Measurement from the experiment\n", + " \"\"\"\n", + "\n", + " qubits = len(G.nodes)\n", + " Hamiltonian = self.create_Hamiltonian(G)\n", + " optimizer, parameter_count = self.optimizer_function(\n", + " self.optimizer, max_iterations, qubits=qubits, circuit_depth=circuit_depth\n", + " )\n", + "\n", + " kernel = self.create_circuit(qubits, circuit_depth)\n", + "\n", + " def objective_function(\n", + " parameter_vector: list[float],\n", + " hamiltonian: cudaq.SpinOperator = Hamiltonian,\n", + " kernel: cudaq.Kernel = kernel,\n", + " ) -> float:\n", + " \"\"\"\n", + "\n", + " Objective function that returns the cost of the simulation\n", + "\n", + " Args:\n", + " parameter_vector (List[float]):\n", + " hamiltonian (cudaq.SpinOperator): Circuit parameter values as a vector\n", + " kernel (cudaq.Kernel) : Circuit configuration\n", + "\n", + " Returns:\n", + " float: Expectation value of the circuit\n", + "\n", + " \"\"\"\n", + "\n", + " get_result = lambda parameter_vector: cudaq.observe(\n", + " kernel, hamiltonian, parameter_vector, qubits, circuit_depth\n", + " ).expectation()\n", + "\n", + " cost = get_result(parameter_vector)\n", + "\n", + " return cost\n", + "\n", + " energy, optimal_parameters = optimizer.optimize(\n", + " dimensions=parameter_count, function=objective_function\n", + " )\n", + "\n", + " counts = cudaq.sample(\n", + " kernel, optimal_parameters, qubits, circuit_depth, shots_count=max_shots\n", + " )\n", + "\n", + " return counts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An instance of the `DivisiveClusteringVQA` class is mostly constructed from variables previously discussed like the functions for building the Hamiltonians and quantum circuits. Parameters related to the quantum simulation can also be specified here such as `circuit_depth` and `max_shots`. The ` threshold_for_max_cut` parameter specifies what percent of the sample results from the quantum computer are checked for the best bitstring value.\n", + "\n", + "The other options specify advanced features like if the data is normalized and how the graph weights are computed.\n", + "\n", + "\n", + "Finally, the `get_divisive_sequence` method performs the iterations and produces the clustering data which we will analyze below. Note that this postprocessing code is not exposed in this tutorial but can be found in the source code. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 129/129 [00:00<00:00, 12075.19it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 35025.50it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 18/18 [00:00<00:00, 44254.09it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 15827.56it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 13617.87it/s]\n" + ] + } + ], + "source": [ + "optimizer = cudaq.optimizers.COBYLA()\n", + "\n", + "divisive_clustering = DivisiveClusteringVQA(\n", + " circuit_depth=circuit_depth,\n", + " max_iterations=max_iterations,\n", + " max_shots=max_shots,\n", + " threshold_for_max_cut=0.75,\n", + " create_Hamiltonian=get_K2_Hamiltonian,\n", + " optimizer=optimizer,\n", + " optimizer_function=get_optimizer,\n", + " create_circuit=get_VQE_circuit,\n", + " normalize_vectors=True,\n", + " sort_by_descending=True,\n", + " coreset_to_graph_metric=\"dist\",\n", + ")\n", + "\n", + "hierarchial_clustering_sequence = divisive_clustering.get_divisive_sequence(coreset_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The data can be nicely visualized with a Dendrogram which maps where the bipartitionings occurred. Early splits generally mark divisions between the least similar data." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAy0AAANICAYAAADKKQDvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA9MElEQVR4nO3deXzU9Z348Xc4EsItCFUEOcQbRSueaAFLtQhatIpFLIqVWkUrtehP2vVAu6Xq6oquUnVV3AqLYLXrsWhVFrteVUHXo2qBB1i0CooSrhCOfH9/uJklJCABwnwgz+fjMQ+Yme985z1DSPLK90hBlmVZAAAAJKpevgcAAADYFNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAtQJnTp1inPPPTffY+zQnnrqqTjkkEOiUaNGUVBQEEuWLMn3SHVWQUFBXHvttfkeA2C7ES3ANjFhwoQoKCjIXRo1ahTt2rWLE088MW677bZYtmxZvkdkKyxevDgGDRoUxcXFcccdd8Tvfve7aNKkySYfM3fu3LjggguiS5cu0ahRo2jevHn07Nkzxo0bF6Wlpdtp8tqxcuXKuPbaa2PGjBn5HmW7ueWWW6KgoCCeffbZjS5zzz33REFBQTz22GO527Isi9/97nfxrW99K1q2bBmNGzeOgw46KH71q1/FypUrq6yjd+/elT6XrH/Zb7/9auW1AelrkO8BgJ3LddddF507d441a9bEp59+GjNmzIiRI0fGLbfcEo899lgcfPDB+R6RLfDaa6/FsmXL4vrrr4++fft+7fJPPvlknHHGGVFUVBRDhw6Nbt26xerVq+OFF16Iyy+/PN599924++67t8PktWPlypUxZsyYiPjqm+ztrbS0NBo02L5fwn/wgx/E5ZdfHpMmTdrox8CkSZOidevW0a9fv4iIWLduXZx11lkxZcqUOO644+Laa6+Nxo0bx3//93/HNddcE1OmTIlnn3022rZtW2k97du3j7Fjx1ZZf4sWLbb9CwN2CKIF2Kb69esXPXr0yF0fPXp0TJ8+PQYMGBCnnHJKvPfee1FcXJzHCTduxYoVX7v1YFtZtWpVFBYWRr16O8YG70WLFkVERMuWLb922Xnz5sUPfvCD6NixY0yfPj1233333H0jRoyIOXPmxJNPPrnVM2VZFqtWrUr246k2NWrUaLs/Z7t27aJPnz7xyCOPxPjx46OoqKjS/R9//HH86U9/ih//+MfRsGHDiIi48cYbY8qUKTFq1Ki46aabcsv++Mc/jkGDBsXAgQNj2LBhVT4eWrRoEWeffXbtvyhgh7FjfLUEdmjHH398XHXVVfHhhx/Ggw8+WOm+999/P04//fRo1apVNGrUKHr06FFp15KI/9v17MUXX4zLLrss2rRpE02aNIlTTz01Pvvss0rLZlkWv/rVr6J9+/bRuHHj6NOnT7z77rtVZqpY5/PPPx8XXXRRtG3bNtq3b5+7/84774wDDzwwioqKol27djFixIhqj+G44447okuXLlFcXBxHHHFE/Pd//3f07t270k/fZ8yYEQUFBTF58uT4h3/4h9hjjz2icePGsXTp0vjiiy9i1KhRcdBBB0XTpk2jefPm0a9fv/if//mfSs9TsY4pU6bEmDFjYo899ohmzZrF6aefHiUlJVFWVhYjR46Mtm3bRtOmTWPYsGFRVla2Wf8+U6dOjcMOOyyKi4tj1113jbPPPjs+/vjj3P29e/eOc845JyIiDj/88CgoKNjk8UE33nhjLF++PO69995KwVKha9eucemll+aur127Nq6//vrYa6+9oqioKDp16hS/+MUvqszfqVOnGDBgQDz99NPRo0ePKC4ujrvuuisiIpYsWRIjR46MDh06RFFRUXTt2jVuuOGGKC8vr7SOyZMnx2GHHRbNmjWL5s2bx0EHHRTjxo2rtMzXrWv+/PnRpk2biIgYM2ZMbtelTR1jcu2110ZBQUGV2ys+DufPn5+77fXXX48TTzwxdt111yguLo7OnTvHeeedV+lxGz5fxfrnzJkT5557brRs2TJatGgRw4YNq7ILVmlpafz0pz+NXXfdNZo1axannHJKfPzxx5t1nMzZZ58dJSUl1Ubn5MmTo7y8PIYMGZJ7nptuuin22WefareanHzyyXHOOefEf/7nf8arr766yecFsKUF2C5++MMfxi9+8Yv44x//GMOHD4+IiHfffTd69uwZe+yxR1x55ZXRpEmTmDJlSgwcODB+//vfx6mnnlppHZdccknssssucc0118T8+fPj1ltvjYsvvjgeeuih3DJXX311/OpXv4qTTjopTjrppJg1a1accMIJsXr16mrnuuiii6JNmzZx9dVXx4oVKyLiq28Ax4wZE3379o0LL7wwPvjggxg/fny89tpr8eKLL+Z+ijx+/Pi4+OKL47jjjouf/exnMX/+/Bg4cGDssssulQKowvXXXx+FhYUxatSoKCsri8LCwvjLX/4Sf/jDH+KMM86Izp07x8KFC+Ouu+6KXr16xV/+8pdo165dpXWMHTs2iouL48orr4w5c+bE7bffHg0bNox69erFl19+Gddee2288sorMWHChOjcuXNcffXVm/x3mTBhQgwbNiwOP/zwGDt2bCxcuDDGjRsXL774YrzxxhvRsmXL+OUvfxn77rtv3H333bnd//baa6+NrvPxxx+PLl26xDHHHLPJ565w/vnnxwMPPBCnn356/PznP48///nPMXbs2Hjvvffi0UcfrbTsBx98EIMHD44LLrgghg8fHvvuu2+sXLkyevXqFR9//HFccMEFseeee8ZLL70Uo0ePjk8++SRuvfXWiIh45plnYvDgwfHtb387brjhhoiIeO+99+LFF1/MRdTmrKtNmzYxfvz4uPDCC+PUU0+N0047LSJim+z6uGjRojjhhBOiTZs2ceWVV0bLli1j/vz58cgjj2zW4wcNGhSdO3eOsWPHxqxZs+Jf//Vfo23btrnXGxFx7rnnxpQpU+KHP/xhHHXUUfH8889H//79N2v9p512Wlx44YUxadKk3OuuMGnSpOjYsWP07NkzIiJeeOGF+PLLL+PSSy/d6K5sQ4cOjfvvvz8ef/zxOOKII3K3r1u3Lj7//PMqyxcXF2+3raFAYjKAbeD+++/PIiJ77bXXNrpMixYtskMPPTR3/dvf/nZ20EEHZatWrcrdVl5enh1zzDHZ3nvvXWXdffv2zcrLy3O3/+xnP8vq16+fLVmyJMuyLFu0aFFWWFiY9e/fv9Jyv/jFL7KIyM4555wq6zz22GOztWvX5m6vWMcJJ5yQrVu3Lnf7v/zLv2QRkd13331ZlmVZWVlZ1rp16+zwww/P1qxZk1tuwoQJWURkvXr1yt32X//1X1lEZF26dMlWrlxZ6T1ZtWpVpefJsiybN29eVlRUlF133XVV1tGtW7ds9erVudsHDx6cFRQUZP369au0jqOPPjrr2LFjtimrV6/O2rZtm3Xr1i0rLS3N3f7EE09kEZFdffXVVd6vTf37ZlmWlZSUZBGRfe9739vkchXefPPNLCKy888/v9Lto0aNyiIimz59eu62jh07ZhGRPfXUU5WWvf7667MmTZpkf/3rXyvdfuWVV2b169fP/va3v2VZlmWXXnpp1rx580r/3hva3HV99tlnWURk11xzzWa9zmuuuSar7ktuxfs6b968LMuy7NFHH92s93nD565Y/3nnnVdpuVNPPTVr3bp17vrMmTOziMhGjhxZablzzz13s1/PGWeckTVq1CgrKSnJ3fb+++9nEZGNHj06d9utt96aRUT26KOPbnRdX3zxRRYR2WmnnZa7rVevXllEVHu54IILvnY+YOdk9zBgu2natGnuLGJffPFFTJ8+PQYNGhTLli2Lzz//PD7//PNYvHhxnHjiiTF79uxKuyhFfLUf/Pq72Bx33HGxbt26+PDDDyMi4tlnn43Vq1fHJZdcUmm5kSNHbnSm4cOHR/369XPXK9YxcuTISsebDB8+PJo3b57bLeb111+PxYsXx/Dhwyv9FHnIkCGxyy67VPtc55xzTpXjL4qKinLPs27duli8eHE0bdo09t1335g1a1aVdQwdOjS3pSci4sgjj4wsy6rsPnTkkUfGggULYu3atRt97a+//nosWrQoLrrookrHSPTv3z/222+/LTruZOnSpRER0axZs81a/j//8z8jIuKyyy6rdPvPf/7ziIgqM3Tu3DlOPPHESrdNnTo1jjvuuNhll11yH0eff/559O3bN9atWxd/+tOfIuKr43FWrFgRzzzzzEbn2dx11ZaKY4aeeOKJWLNmTY0f/5Of/KTS9eOOOy4WL16c+3d56qmnIuKrLYzru+SSSzb7Oc4+++xYtWpVpa0/kyZNiojI7RoWEbn/65v6WKi4b8OzC3bq1CmeeeaZKpdN/V8Gdm52DwO2m+XLl+fOEjRnzpzIsiyuuuqquOqqq6pdftGiRbHHHnvkru+5556V7q+Igy+//DIiIhcve++9d6Xl2rRps9GQ6Ny5c6XrFevYd999K91eWFgYXbp0yd1f8WfXrl0rLdegQYPo1KnTZj1XRER5eXmMGzcu7rzzzpg3b16sW7cud1/r1q2rLL/he1BxNqUOHTpUub28vDxKSkqqXc/6r2HD1xoRsd9++8ULL7xQ7eM2pXnz5hFR9ZvQjfnwww+jXr16Vd7H3XbbLVq2bJmbsUJ17+Hs2bPjrbfeyh1nsqGKkwhcdNFFMWXKlOjXr1/sscceccIJJ8SgQYPiu9/9bo3XVVt69eoV3//+92PMmDHxz//8z9G7d+8YOHBgnHXWWVUOfK/Opv6PNG/ePPd+b/g+bvj+b0q/fv2iVatWMWnSpNyxTf/+7/8e3bt3jwMPPDC33MaCZH0V92149rAmTZps1lnqgLpDtADbxUcffRQlJSW5b44qDmoeNWpUlZ+cV9jwG6n1t4isL8uyLZ5re555qrrn+vWvfx1XXXVVnHfeeXH99ddHq1atol69ejFy5MgqB5FHbPw9qI33Zks0b9482rVrF++8806NHlfdQerVqe49LC8vj+985ztxxRVXVPuYffbZJyK++sb4zTffjKeffjqmTZsW06ZNi/vvvz+GDh0aDzzwQI3WVVMbe33rR2rFcg8//HC88sor8fjjj8fTTz8d5513Xtx8883xyiuvRNOmTTf5PNvj46Bhw4YxaNCguOeee2LhwoXxt7/9LWbPnh033nhjpeUOOOCAiIh46623YuDAgdWu66233oqIiC5dumyz+YCdk2gBtovf/e53ERG5QKn4JqVhw4bb7CeqHTt2jIivflq+/jdBn332WW5rzOau44MPPqi0jtWrV8e8efNys1YsN2fOnOjTp09uubVr18b8+fM3+6Dshx9+OPr06RP33ntvpduXLFkSu+6662atY0ut/1qPP/74Svd98MEHuftrasCAAXH33XfHyy+/HEcfffTXzlBeXh6zZ8+O/fffP3f7woULY8mSJZs1w1577RXLly/frI+jwsLCOPnkk+Pkk0+O8vLyuOiii+Kuu+6Kq666Krp27brZ69rcyKpQscVjyZIllU4bveGWpApHHXVUHHXUUfGP//iPMWnSpBgyZEhMnjw5zj///Bo974Yq3u958+ZV2iI5Z86cGq1nyJAh8dvf/jYeeuihmDdvXhQUFMTgwYMrLdOzZ89o2bJlTJo0KX75y19WG1T/9m//FhERZ5xxxha8GqAucUwLUOumT58e119/fXTu3Dm3z3vbtm2jd+/ecdddd8Unn3xS5TEbnsp4c/Tt2zcaNmwYt99+e6WfLFecPWpz11FYWBi33XZbpXXce++9UVJSkjvLUo8ePaJ169Zxzz33VDpuZOLEiZsdSBFf/WR8w5+CT506tcrxPLWhR48e0bZt2/jtb39b6fTC06ZNi/fee2+zzyi1oSuuuCKaNGkS559/fixcuLDK/XPnzs2dZvikk06KiKr/RrfccktExGbNMGjQoHj55Zfj6aefrnLfkiVLcv8+ixcvrnRfvXr1cnFZ8fo3d12NGzfO3bY5Ks62tv4xMStWrMht4anw5ZdfVvl4OOSQQyrNuDUqfmhw5513Vrr99ttvr9F6evbsGZ06dYoHH3wwHnrooejVq1eVM+Y1btw4rrjiivjggw/il7/8ZZV1PPnkkzFhwoQ4+eST46CDDqrhKwHqGltagG1q2rRp8f7778fatWtj4cKFMX369HjmmWeiY8eO8dhjj1U64PuOO+6IY489Ng466KAYPnx4dOnSJRYuXBgvv/xyfPTRR1V+V8nXadOmTYwaNSrGjh0bAwYMiJNOOineeOONmDZt2mZvtWjTpk2MHj06xowZE9/97nfjlFNOiQ8++CDuvPPOOPzww3O/8K6wsDCuvfbauOSSS+L444+PQYMGxfz582PChAmx1157bfZP4gcMGBDXXXddDBs2LI455ph4++23Y+LEidtld5mGDRvGDTfcEMOGDYtevXrF4MGDc6c87tSpU/zsZz/bovXutddeMWnSpDjzzDNj//33j6FDh0a3bt1i9erV8dJLL8XUqVNzx0J07949zjnnnLj77rtjyZIl0atXr3j11VfjgQceiIEDB1bairUxl19+eTz22GMxYMCAOPfcc+Owww6LFStWxNtvvx0PP/xwzJ8/P3bdddc4//zz44svvojjjz8+2rdvHx9++GHcfvvtccghh+S28mzuuoqLi+OAAw6Ihx56KPbZZ59o1apVdOvWLbp161btjCeccELsueee8aMf/Sguv/zyqF+/ftx3333Rpk2b+Nvf/pZb7oEHHog777wzTj311Nhrr71i2bJlcc8990Tz5s1zgbc1DjvssPj+978ft956ayxevDh3yuO//vWvEbH5W5AKCgrirLPOil//+tcREXHddddVu9wVV1wRb775Ztxwww3x8ssvx/e///0oLi6OF154IR588ME48MADY8KECVUeV1JSUuV3OlXwSyehjsrbecuAnUrFqVsrLoWFhdluu+2Wfec738nGjRuXLV26tNrHzZ07Nxs6dGi22267ZQ0bNsz22GOPbMCAAdnDDz9cZd0bnga24jTA//Vf/5W7bd26ddmYMWOy3XffPSsuLs569+6dvfPOO1nHjh2rPeXxxk4t+y//8i/ZfvvtlzVs2DD7xje+kV144YXZl19+WWW52267LevYsWNWVFSUHXHEEdmLL76YHXbYYdl3v/vdKnNOnTq1yuNXrVqV/fznP8/N27Nnz+zll1/OevXqVe1pkzdcx8ZeR8UpcD/77LNqX9/6HnrooezQQw/NioqKslatWmVDhgzJPvroo816nk3561//mg0fPjzr1KlTVlhYmDVr1izr2bNndvvtt1c6zfWaNWuyMWPGZJ07d84aNmyYdejQIRs9enSlZbLsq1Me9+/fv9rnWrZsWTZ69Oisa9euWWFhYbbrrrtmxxxzTPZP//RPuVNEP/zww9kJJ5yQtW3bNissLMz23HPP7IILLsg++eSTGq8ry7LspZdeyg477LCssLBws04XPHPmzOzII4/MPfctt9xS5ZTHs2bNygYPHpztueeeWVFRUda2bdtswIAB2euvv15pXRs+38b+vTdcf5Zl2YoVK7IRI0ZkrVq1ypo2bZoNHDgw++CDD7KIyH7zm99s8jWs7913380iIisqKqr2/0aF8vLybMKECVnPnj2zZs2a5T5H9O3bNysrK6uy/KZOeezbFqi7CrJsOx+lCbATKy8vjzZt2sRpp50W99xzT77Hgc3y5ptvxqGHHhoPPvhgpdMW14Y1a9bEySefHM8991w8/vjjlc7eBrAxjmkB2EKrVq2qcvzBv/3bv8UXX3wRvXv3zs9Q8DVKS0ur3HbrrbdGvXr14lvf+latP3/Dhg3j97//fRxyyCFxxhlnVPv7iAA2ZEsLwBaaMWNG/OxnP4szzjgjWrduHbNmzYp777039t9//5g5c2YUFhbme0SoYsyYMTFz5szo06dPNGjQIHf65x//+Mdx11135Xs8gGqJFoAtNH/+/PjpT38ar776anzxxRfRqlWrOOmkk+I3v/lNlV+WB6l45plnYsyYMfGXv/wlli9fHnvuuWf88Ic/jF/+8pfRoIHz8wBpEi0AAEDSHNMCAAAkTbQAAABJ2+47r5aXl8ff//73aNas2Wb/EisAAGDnk2VZLFu2LNq1axf16m18e8p2j5a///3v0aFDh+39tAAAQKIWLFgQ7du33+j92z1amjVrFhFfDda8efPt/fQAAEAili5dGh06dMg1wsZs92ip2CWsefPmogUAAPjaw0YciA8AACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQtAb5HgDyKcuyKF2zLt9jAMB2U9ywfhQUFOR7DKgR0UKdlWVZnP7bl2Pmh1/mexQA2G56dNwlpv7kaOHCDsXuYdRZpWvWCRYA6pzXP/zSXgbscGxpgYh4/R/6RuPC+vkeAwBqzcrV66LHr57N9xiwRUQLRETjwvrRuNB/BwCAFNk9DAAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJJWo2i59tpro6CgoNJlv/32q63ZAAAAokFNH3DggQfGs88++38raFDjVQAAAGy2GhdHgwYNYrfddquNWQAAAKqo8TEts2fPjnbt2kWXLl1iyJAh8be//a025gIAAIiIGm5pOfLII2PChAmx7777xieffBJjxoyJ4447Lt55551o1qxZtY8pKyuLsrKy3PWlS5du3cQAAECdUqNo6devX+7vBx98cBx55JHRsWPHmDJlSvzoRz+q9jFjx46NMWPGbN2UAABAnbVVpzxu2bJl7LPPPjFnzpyNLjN69OgoKSnJXRYsWLA1TwkAANQxWxUty5cvj7lz58buu+++0WWKioqiefPmlS4AAACbq0bRMmrUqHj++edj/vz58dJLL8Wpp54a9evXj8GDB9fWfAAAQB1Xo2NaPvrooxg8eHAsXrw42rRpE8cee2y88sor0aZNm9qaDwAAqONqFC2TJ0+urTkAAACqtVXHtAAAANQ20QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkLQG+R6Ar5dlWZSuWZfvMXY6K1evrfbvbDvFDetHQUFBvscAAHZwoiVxWZbF6b99OWZ++GW+R9mp9fjVc/keYafUo+MuMfUnRwsXAGCr2D0scaVr1gkWdlivf/ilrYQAwFazpWUH8vo/9I3GhfXzPQZ8rZWr10WPXz2b7zEAgJ2EaNmBNC6sH40L/ZMBAFC32D0MAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACStlXR8pvf/CYKCgpi5MiR22gcAACAyrY4Wl577bW466674uCDD96W8wAAAFSyRdGyfPnyGDJkSNxzzz2xyy67bOuZAAAAcrYoWkaMGBH9+/ePvn37but5AAAAKmlQ0wdMnjw5Zs2aFa+99tpmLV9WVhZlZWW560uXLq3pUwIAAHVYjba0LFiwIC699NKYOHFiNGrUaLMeM3bs2GjRokXu0qFDhy0aFAAAqJtqFC0zZ86MRYsWxTe/+c1o0KBBNGjQIJ5//vm47bbbokGDBrFu3boqjxk9enSUlJTkLgsWLNhmwwMAADu/Gu0e9u1vfzvefvvtSrcNGzYs9ttvv/h//+//Rf369as8pqioKIqKirZuSgAAoM6qUbQ0a9YsunXrVum2Jk2aROvWravcDgAAsC1s1S+XBAAAqG01PnvYhmbMmLENxgAAAKieLS0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJq1G0jB8/Pg4++OBo3rx5NG/ePI4++uiYNm1abc0GAABQs2hp3759/OY3v4mZM2fG66+/Hscff3x873vfi3fffbe25gMAAOq4BjVZ+OSTT650/R//8R9j/Pjx8corr8SBBx64TQcDAACIqGG0rG/dunUxderUWLFiRRx99NHbciYAAICcGkfL22+/HUcffXSsWrUqmjZtGo8++mgccMABG12+rKwsysrKcteXLl26ZZMCAAB1Uo3PHrbvvvvGm2++GX/+85/jwgsvjHPOOSf+8pe/bHT5sWPHRosWLXKXDh06bNXAAABA3VLjaCksLIyuXbvGYYcdFmPHjo3u3bvHuHHjNrr86NGjo6SkJHdZsGDBVg0MAADULVt8TEuF8vLySrt/baioqCiKioq29mkAAIA6qkbRMnr06OjXr1/sueeesWzZspg0aVLMmDEjnn766dqaDwAAqONqFC2LFi2KoUOHxieffBItWrSIgw8+OJ5++un4zne+U1vzAQAAdVyNouXee++trTkAAACqVeMD8QEAALYn0QIAACRtq88eBtRMlmVRurY032PUqpVr1q3399KIgvp5nGb7KG5QHAUFBfkeAwB2SqIFtqMsy2LotKHx5mdv5nuUWpWVN4yI6yMioveUXlFQb01+B9oODm17aDzw3QeECwDUAtEC21Hp2tKdPlgiIgrqrYlm+1+Z7zG2qzcWvRGla0ujccPG+R4FAHY6ogXyZMagGVHcoDjfY7CVSteWRu8pvfM9BgDs1EQL5Elxg2I/lQcA2AzOHgYAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASatRtIwdOzYOP/zwaNasWbRt2zYGDhwYH3zwQW3NBgAAULNoef7552PEiBHxyiuvxDPPPBNr1qyJE044IVasWFFb8wEAAHVcg5os/NRTT1W6PmHChGjbtm3MnDkzvvWtb23TwQAAACJqGC0bKikpiYiIVq1abXSZsrKyKCsry11funTp1jwlAABQx2zxgfjl5eUxcuTI6NmzZ3Tr1m2jy40dOzZatGiRu3To0GFLnxIAAKiDtjhaRowYEe+8805Mnjx5k8uNHj06SkpKcpcFCxZs6VMCAAB10BbtHnbxxRfHE088EX/605+iffv2m1y2qKgoioqKtmg4AACAGkVLlmVxySWXxKOPPhozZsyIzp0719ZcAAAAEVHDaBkxYkRMmjQp/uM//iOaNWsWn376aUREtGjRIoqLi2tlQAAAoG6r0TEt48ePj5KSkujdu3fsvvvuuctDDz1UW/MBAAB1XI13DwPIhyzLonRtab7HqGL9mVKcr7hBcRQUFOR7DADYKlv1e1oAtocsy2LotKHx5mdv5nuUTeo9pXe+R6ji0LaHxgPffUC4ALBD2+JTHgNsL6VrS5MPllS9seiNJLcAAUBN2NIC7FBmDJoRxQ2c+OPrlK4tTXLLDwBsCdEC7FCKGxRH44aN8z0GALAd2T0MAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACS1iDfAyQjyyLWrMz3FFWtXrfe31dGRP28jbJRDRtHFBTkewoAAHZSoiXiq2C578SIBX/O9yRVZUURcf9Xf7+pa0RBWV7HqVaHoyLOe0q4AABQK0RLxFdbWFIMlohoXFAW8xudle8xNm3BK1+9h4VN8j0JAAA7IdGyoVFzIgob53uKHcPqlRH/1DXfUwAAsJMTLRsqbGyLAQAAJMTZwwAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABImmgBAACSJloAAICkiRYAACBpogUAAEiaaAEAAJImWgAAgKSJFgAAIGmiBQAASJpoAQAAkiZaAACApIkWAAAgaaIFAABIWoN8DwAAsL4syyIrLc33GDud8tXr/u/vK0ujfG39PE6zcyooLo6CgoJ8j7FTEi0AQDKyLIsPzxoSpW+8ke9Rdjqr6hdGnPzriIiY3fPYaLRudZ4n2vkUf/Ob0XHig8KlFogWACAZWWmpYKkljdatjml/GJXvMXZqpbNmRVZaGgWNG+d7lJ2OaAEAkrT3iy9EveLifI8BX6u8tDRm9zw232Ps1EQLAJCkesXFUc9PrIFw9jAAACBxNY6WP/3pT3HyySdHu3btoqCgIP7whz/UwlgAAABfqXG0rFixIrp37x533HFHbcwDAABQSY2PaenXr1/069evNmYBAACootYPxC8rK4uysrLc9aVLl9b2UwIAADuRWj8Qf+zYsdGiRYvcpUOHDrX9lAAAwE6k1qNl9OjRUVJSkrssWLCgtp8SAADYidT67mFFRUVRVFRU208DAADspPyeFgAAIGk13tKyfPnymDNnTu76vHnz4s0334xWrVrFnnvuuU2HAwAAqHG0vP7669GnT5/c9csuuywiIs4555yYMGHCNhsMAAAgYguipXfv3pFlWW3MAgAAUIVjWgAAgKTV+tnDAABgW8iyLLLS0nyPUUX5ejOVJzhfRERBcXEUFBTke4wtJloAAEhelmXx4VlDovSNN/I9yibN7nlsvkeoVvE3vxkdJz64w4aL3cMAAEheVlqafLCkrHTWrCS3Um0uW1oAANih7P3iC1GvuDjfY+wQyktLk936UxOiBQCAHUq94uKo17hxvsdgO7J7GAAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJEy0AAEDSRAsAAJA00QIAACRNtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASWuQ7wEAgM2TZVlkpaX5HqNWla/3+sp38tcaEVFQXBwFBQX5HgOSJ1oAYAeQZVl8eNaQKH3jjXyPst3M7nlsvkeodcXf/GZ0nPigcIGvYfcwANgBZKWldSpY6orSWbN2+q1nsC3Y0gIAO5i9X3wh6hUX53sMtkJ5aWmd2JIE24poAYAdTL3i4qjXuHG+xwDYbuweBgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJc8pjAFhPlmVJ/rK/8vVmKk9wvoLiYr/VHag1ogUA/leWZfHhWUOS/83zKf5SwuJvfjM6TnxQuAC1wu5hAPC/stLS5IMlVaWzZiW5hQrYOdjSAgDV2PvFF6JecXG+x0heeWlpklt+gJ3LFkXLHXfcETfddFN8+umn0b1797j99tvjiCOO2NazAUDe1CsujnqNG+d7DABiC3YPe+ihh+Kyyy6La665JmbNmhXdu3ePE088MRYtWlQb8wEAAHVcjaPllltuieHDh8ewYcPigAMOiN/+9rfRuHHjuO+++2pjPgAAoI6r0e5hq1evjpkzZ8bo0aNzt9WrVy/69u0bL7/8crWPKSsri7Kystz1kpKSiIhYunTplsxbO1aviCjLvvr70qURhevyO8+OwvtWYyvXrIx1pV+9T0uXLo21DdfmeaIdg/et5rxnW6Z85cpYvu7/3rd6a71vX8d7tmW8bzXnPdsyqb9vFU2QZdmmF8xq4OOPP84iInvppZcq3X755ZdnRxxxRLWPueaaa7KIcHFxcXFxcXFxcXFxqfayYMGCTXZIrZ89bPTo0XHZZZflrpeXl8cXX3wRrVu3di53AACow7Isi2XLlkW7du02uVyNomXXXXeN+vXrx8KFCyvdvnDhwthtt92qfUxRUVEUFRVVuq1ly5Y1eVoAAGAn1aJFi69dpkYH4hcWFsZhhx0Wzz33XO628vLyeO655+Loo4+u+YQAAABfo8a7h1122WVxzjnnRI8ePeKII46IW2+9NVasWBHDhg2rjfkAAIA6rsbRcuaZZ8Znn30WV199dXz66adxyCGHxFNPPRXf+MY3amM+AACgjivIvvb8YgAAAPlT418uCQAAsD2JFgAAIGmiBQAASJpoAQAAkiZa/tedd94ZBQUFceSRR+Z7lORNmDAhCgoKKl3atm0bffr0iWnTpuV7vKTNnTs3LrjggujSpUs0atQomjdvHj179oxx48ZFaWlpvsdLSsXH2euvv17t/b17945u3bpt56l2PF/3PvJ/qvvcVnG58sor8z1e0nyc1cy8efPi4osvjn322ScaN24cjRs3jgMOOCBGjBgRb731Vr7HS86G/zcbNWoU7dq1ixNPPDFuu+22WLZsWb5HTNKmPqcVFBTEK6+8ku8Ra6TGpzzeWU2cODE6deoUr776asyZMye6du2a75GSd91110Xnzp0jy7JYuHBhTJgwIU466aR4/PHHY8CAAfkeLzlPPvlknHHGGVFUVBRDhw6Nbt26xerVq+OFF16Iyy+/PN599924++678z0m1HkVn9vWJ5DZVp544ok488wzo0GDBjFkyJDo3r171KtXL95///145JFHYvz48TFv3rzo2LFjvkdNTsX/zTVr1sSnn34aM2bMiJEjR8Ytt9wSjz32WBx88MH5HjFJ1X1Oi4gd7ntd0RJf/cTjpZdeikceeSQuuOCCmDhxYlxzzTX5Hit5/fr1ix49euSu/+hHP4pvfOMb8e///u+iZQPz5s2LH/zgB9GxY8eYPn167L777rn7RowYEXPmzIknn3wyjxMCFTb83Abbyty5c3NfC5577rlKXwsiIm644Ya48847o149O8JUZ8P/m6NHj47p06fHgAED4pRTTon33nsviouL8zhhmnaWz2n+V8RXW1l22WWX6N+/f5x++ukxceLEfI+0Q2rZsmUUFxdHgwZaeEM33nhjLF++PO69994qX6Qivvppx6WXXpqHyQDYXm688cZYsWJF3H///dV+LWjQoEH89Kc/jQ4dOuRhuh3T8ccfH1dddVV8+OGH8eCDD+Z7HGqRaImvouW0006LwsLCGDx4cMyePTtee+21fI+VvJKSkvj888/js88+i3fffTcuvPDCWL58eZx99tn5Hi05jz/+eHTp0iWOOeaYfI+yw6n4ONvwsmbNmnyPxk6quo852BaeeOKJ6Nq1q+Nnt7Ef/vCHERHxxz/+Mc+TpKm6z2mLFy/O91g1Vud/JD5z5sx4//334/bbb4+IiGOPPTbat28fEydOjMMPPzzP06Wtb9++la4XFRXFfffdF9/5znfyNFGali5dGh9//HF873vfy/coO6QNP87Wd+CBB27HSagrqvuYy7IsD5OwM1m6dGn8/e9/j4EDB1a5b8mSJbF27drc9SZNmtjNqQbat28fLVq0iLlz5+Z7lCRV9zmtqKgoVq1alYdptlydj5aJEyfGN77xjejTp09ERBQUFMSZZ54ZDz74YNx8881Rv379PE+YrjvuuCP22WefiIhYuHBhPPjgg3H++edHs2bN4rTTTsvzdOlYunRpREQ0a9Ysz5PsmNb/OFvfz3/+81i3bl0eJmJnt7GPOdgaFV8LmjZtWuW+3r17x//8z//krt90000xatSo7TbbzqBp06bOIrYR1X1O2xG/v63T0bJu3bqYPHly9OnTJ+bNm5e7/cgjj4ybb745nnvuuTjhhBPyOGHajjjiiEoHdg0ePDgOPfTQuPjii2PAgAFRWFiYx+nS0bx584gIn0y30IYfZxV22WUXu+1QKzb2MQdbo+IHV8uXL69y31133RXLli2LhQsX2sV6Cy1fvjzatm2b7zGStLN8TqvT0TJ9+vT45JNPYvLkyTF58uQq90+cOFG01EC9evWiT58+MW7cuJg9e7Zdd/5X8+bNo127dvHOO+/kexQA8qRFixax++67V/u1oOIYl/nz52/nqXYOH330UZSUlOxwp/ClZur0gfgTJ06Mtm3bxtSpU6tcBg8eHI8++qhf+FdDFfvkVveTpLpswIABMXfu3Hj55ZfzPQoAedK/f/+YM2dOvPrqq/keZafyu9/9LiIiTjzxxDxPQm2qs9FSWloajzzySAwYMCBOP/30KpeLL744li1bFo899li+R91hrFmzJv74xz9GYWFh7L///vkeJylXXHFFNGnSJM4///xYuHBhlfvnzp0b48aNy8NkAGwvV1xxRTRu3DjOO++8ar8WOOFDzU2fPj2uv/766Ny5cwwZMiTf41CL6uzuYY899lgsW7YsTjnllGrvP+qoo6JNmzYxceLEOPPMM7fzdDuGadOmxfvvvx8REYsWLYpJkybF7Nmz48orr8wdx8FX9tprr5g0aVKceeaZsf/++8fQoUOjW7dusXr16njppZdi6tSpce655+Z7TABq0d577x2TJk2KwYMHx7777htDhgyJ7t27R5ZlMW/evJg0aVLUq1cv2rdvn+9Rk1TxfcfatWtj4cKFMX369HjmmWeiY8eO8dhjj0WjRo3yPWKS1v9+bX3HHHNMdOnSJQ8TbZk6Gy0TJ06MRo0abfT0vPXq1Yv+/fvHxIkTY/HixdG6devtPGH6rr766tzfGzVqFPvtt1+MHz8+LrjggjxOla5TTjkl3nrrrbjpppviP/7jP2L8+PFRVFQUBx98cNx8880xfPjwfI8IsEUqthDsiGck2t6+973vxdtvvx0333xz/PGPf4z77rsvCgoKomPHjtG/f//4yU9+Et27d8/3mEmq+L6jsLAwWrVqFQcddFDceuutMWzYMGfo3IT1v19b3/33379DRUtBZlskALAVbrvttrj00ktjzpw5sddee+V7HGAnVGePaQEAto3XXnstmjRpEh07dsz3KMBOqs7uHgYAbJ3f//73MWPGjJg4cWKcf/750aCBbyuA2mH3MABgi3Tu3DmWLVsWp556atx6663RpEmTfI8E7KRECwAAkDTHtAAAAEkTLQAAQNJECwAAkDTRAgAAJE20AAAASRMtAABA0kQLAACQNNECAAAkTbQAAABJ+/9NVsdwRnDnBwAAAABJRU5ErkJggg==", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dendo = Dendrogram(coreset_df, hierarchial_clustering_sequence)\n", + "dendo.plot_dendrogram(plot_title=\"Dendrogram of Coreset using VQE\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each branch point in the dendrogram aboves corresponds to one of the plots below. Notice the first iterations are the most complicated, and the final iterations become trivial bipartitioning of two points. Occasionally, especially in the first iteration, the partitioning might be puzzling at first glance. The data might seem to naturally cluster into two groups. However, there are cases where a stray point seems to belong in the wrong cluster. There are two explanations for this. 1) The quantum sampling is approximate and stochastic. It is possible that too few shots were taken to sample the ground state of the problem. 2) It is important to remember that we are clustering coresets and not data points. There can be cases where it is optimal to pay a penalty by excluding a point based on proximity if the weights are small enough that the penalty has less impact. Usually, if a point looks unusually clustered and you go look at the original coresets plotted above, that point will have a small weight." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Dendrogram.plot_hierarchial_split(hierarchial_clustering_sequence, coreset_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The hierarchical clustering can be converted to flat clustering by drawing a line perpendicular to the branches. Any data point that intersects the line is considered to be in the same cluster. The function below performs this task at threshold height of 1.5. If you want to use the number of clusters instead of height, you can use `dendo.get_clusters_using_k()` method. You pass the number of desired clusters as an argument. The figure below shows the clusters that are formed at threshold height of 1.5." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "threshold_height = 1\n", + "clusters = dendo.get_clusters_using_height(threshold_height)\n", + "colors = [\"red\", \"blue\", \"green\", \"black\", \"purple\", \"orange\", \"yellow\"]\n", + "dendo.plot_dendrogram(\n", + " plot_title=\"Dendrogram of Coreset using VQE\",\n", + " colors=colors,\n", + " clusters=clusters,\n", + " color_threshold=threshold_height,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can visualize the flat clusters using `dendo.plot_clusters()` method. The function takes the clusters and colors as arguments. The clusters are represented by different colors." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dendo.plot_clusters(\n", + " clusters, colors, plot_title=\"Clusters of Coreset using VQE\", show_annotation=True\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The function below uses the `dendo.get_voronoi_tessalation()` method to convert the clusters into regions. `coreset_df`, `clusters` and `colors` need to be passed as the arguments to create the regions. This function creates a region for each coreset point separately and then colors them according to the clusters with colors passed as arguments. Another option is to create regions using the centroids of the clusters. You need to pass `tesslation_by_cluster=True` to the function to perform this task.\n", + "\n", + "Once the region creation is complete, you can use `plot_voironi()` method to plot the regions. The function takes the clusters and colors as arguments. \n", + "\n", + "Remembering that these regions were based on coresets, they can overlay the original data set and be used to cluster the data based on the coreset analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "vt = Voironi_Tessalation(coreset_df, clusters, colors, tesslation_by_cluster=False)\n", + "vt.plot_voironi(plot_title=\"Voironi Tessalation of Coreset using VQE\", show_annotation=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## QAOA Implementation\n", + "\n", + "CUDA-Q is designed to be a flexible tool for developers so they can test different implementations of the same code. For example, one can perform the same analysis, instead using a QAOA approach. Only the kernel needs to be changed as is done below." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " »\n", + "q0 : ──●──────────────────●──────────────────────────────────────────────────»\n", + " ╭─┴─╮╭────────────╮╭─┴─╮ »\n", + "q1 : ┤ x ├┤ rz(0.3527) ├┤ x ├──●──────────────────●──────────────────────────»\n", + " ╰───╯╰────────────╯╰───╯╭─┴─╮╭────────────╮╭─┴─╮ »\n", + "q2 : ────────────────────────┤ x ├┤ rz(0.3527) ├┤ x ├──●──────────────────●──»\n", + " ╰───╯╰────────────╯╰───╯╭─┴─╮╭────────────╮╭─┴─╮»\n", + "q3 : ────────────────────────────────────────────────┤ x ├┤ rz(0.3527) ├┤ x ├»\n", + " ╰───╯╰────────────╯╰───╯»\n", + "q4 : ────────────────────────────────────────────────────────────────────────»\n", + " »\n", + "\n", + "################################################################################\n", + "\n", + " ╭───╮╭────────────╮╭───╮╭───────────╮\n", + "────────────────────────┤ x ├┤ rz(0.3527) ├┤ x ├┤ rx(1.111) ├\n", + " ╰─┬─╯╰────────────╯╰─┬─╯├───────────┤\n", + "──────────────────────────┼──────────────────┼──┤ rx(1.111) ├\n", + " │ │ ├───────────┤\n", + "──────────────────────────┼──────────────────┼──┤ rx(1.111) ├\n", + " │ │ ├───────────┤\n", + "──●──────────────────●────┼──────────────────┼──┤ rx(1.111) ├\n", + "╭─┴─╮╭────────────╮╭─┴─╮ │ │ ├───────────┤\n", + "┤ x ├┤ rz(0.3527) ├┤ x ├──●──────────────────●──┤ rx(1.111) ├\n", + "╰───╯╰────────────╯╰───╯ ╰───────────╯\n", + "\n" + ] + } + ], + "source": [ + "def get_QAOA_circuit(number_of_qubits, circuit_depth) -> cudaq.Kernel:\n", + " \"\"\"Returns the QAOA circuit for the given number of qubits and circuit depth\n", + "\n", + "\n", + " Args:\n", + " number_of_qubits (int): Number of qubits\n", + " circuit_depth (int): Circuit depth\n", + "\n", + " Returns:\n", + " cudaq.Kernel: QAOA Circuit\n", + " \"\"\"\n", + "\n", + " @cudaq.kernel\n", + " def kernel(thetas: list[float], number_of_qubits: int, circuit_depth: int):\n", + " qubits = cudaq.qvector(number_of_qubits)\n", + "\n", + " layers = circuit_depth\n", + "\n", + " for layer in range(layers):\n", + " for qubit in range(number_of_qubits):\n", + " cx(qubits[qubit], qubits[(qubit + 1) % number_of_qubits])\n", + " rz(2.0 * thetas[layer], qubits[(qubit + 1) % number_of_qubits])\n", + " cx(qubits[qubit], qubits[(qubit + 1) % number_of_qubits])\n", + "\n", + " rx(2.0 * thetas[layer + layers], qubits)\n", + "\n", + " return kernel\n", + "\n", + "\n", + "circuit = get_QAOA_circuit(5, circuit_depth)\n", + "\n", + "print(cudaq.draw(circuit, np.random.rand(2 * circuit_depth), 5, circuit_depth))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def get_optimizer(\n", + " optimizer: cudaq.optimizers.optimizer, max_iterations, **kwargs\n", + ") -> Tuple[cudaq.optimizers.optimizer, int]:\n", + " \"\"\"\n", + " Returns the optimizer with the given parameters\n", + "\n", + " Args:\n", + " optimizer (cudaq.optimizers.optimizer): Optimizer\n", + " max_iterations (int): Maximum number of iterations\n", + " **kwargs: Additional arguments\n", + "\n", + " Returns:\n", + " tuple(cudaq.optimizers.optimizer, int): Optimizer and parameter count\n", + " \"\"\"\n", + "\n", + " parameter_count = 2 * kwargs[\"circuit_depth\"]\n", + " optimizer.initial_parameters = np.random.uniform(-np.pi / 8.0, np.pi / 8.0, parameter_count)\n", + " optimizer.max_iterations = max_iterations\n", + " return optimizer, parameter_count" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 484/484 [00:00<00:00, 12163.89it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 52703.30it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 48/48 [00:00<00:00, 31987.07it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 36393.09it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 37957.50it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 42473.96it/s]\n" + ] + } + ], + "source": [ + "optimizer = cudaq.optimizers.COBYLA()\n", + "\n", + "divisive_clustering = DivisiveClusteringVQA(\n", + " circuit_depth=circuit_depth,\n", + " max_iterations=max_iterations,\n", + " max_shots=max_shots,\n", + " threshold_for_max_cut=0.75,\n", + " create_Hamiltonian=get_K2_Hamiltonian,\n", + " optimizer=optimizer,\n", + " optimizer_function=get_optimizer,\n", + " create_circuit=get_QAOA_circuit,\n", + " normalize_vectors=True,\n", + " sort_by_descending=True,\n", + " coreset_to_graph_metric=\"dist\",\n", + ")\n", + "\n", + "hierarchial_clustering_sequence = divisive_clustering.get_divisive_sequence(coreset_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scaling simulations with CUDA-Q\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The University of Edinburgh team quickly encountered scaling challenges when they were developing this method. By developing with CUDA-Q they were able to port their code to an HPC environment once GPUs became available. GPUs massively accelerated their development and testing and allowed them to produce the 25 qubit experiments presented in their publication. If you have a GPU available, run the following code examples and see how the times compare on your device. Each call executes the divisive clustering procedure using the QAOA method, 100000 simulated shots for each VQE loop, and maximum 75 VQE iterations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, try a slightly larger N=18 problem using the CPU (`qpp-cpu`) backend." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Uncomment the following line if you want to explicitly execute this step on your system.\n", + "# !python3 divisive_clustering_src/main_divisive_clustering.py --target qpp-cpu --M 18" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now try the N=18 example on the GPU backend (`nvidia`)." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using BFL2 method to generate coresets\n", + "100%|███████████████████████████████████████| 751/751 [00:00<00:00, 3460.26it/s]\n", + "100%|████████████████████████████████████████| 16/16 [00:00<00:00, 42771.74it/s]\n", + "100%|█████████████████████████████████████| 4064/4064 [00:00<00:00, 6862.37it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 56871.92it/s]\n", + "100%|████████████████████████████████████████| 16/16 [00:00<00:00, 44979.13it/s]\n", + "100%|██████████████████████████████████████| 128/128 [00:00<00:00, 19366.94it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 53773.13it/s]\n", + "100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 54648.91it/s]\n", + "100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 51941.85it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 56111.09it/s]\n", + "Total time for the execution: 461.866833317\n", + "Total time spent on CUDA-Q: 10.452308367999706\n" + ] + } + ], + "source": [ + "!python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia --M 18" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Scaling up to N=25, the task becomes even more onerous on a CPU. Depending on your device, the simulation may not even run. Try it and feel free to interrupt after your patience has worn out." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# target = 'qpp-cpu'\n", + "# Uncomment the following line if you want to explicitly execute this step on your system.\n", + "# !python3 divisive_clustering_src/main_divisive_clustering.py --target qpp-cpu --M 25" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "N=25 can still easily be completed by a single GPU." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using BFL2 method to generate coresets\n", + "100%|█████████████████████████████████████| 7352/7352 [00:03<00:00, 2063.82it/s]\n", + "100%|███████████████████████████████████| 16492/16492 [00:03<00:00, 4739.44it/s]\n", + "100%|██████████████████████████████████████| 256/256 [00:00<00:00, 15185.58it/s]\n", + "100%|████████████████████████████████████████| 64/64 [00:00<00:00, 23728.05it/s]\n", + "100%|██████████████████████████████████████| 256/256 [00:00<00:00, 15437.97it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 50840.05it/s]\n", + "100%|████████████████████████████████████████| 32/32 [00:00<00:00, 33562.82it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 54120.05it/s]\n", + "100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 54560.05it/s]\n", + "100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 55924.05it/s]\n", + "100%|████████████████████████████████████████| 16/16 [00:00<00:00, 42717.29it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 55007.27it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 53601.33it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 47127.01it/s]\n", + "Total time for the execution: 67.61674502899999\n", + "Total time spent on CUDA-Q: 21.439895901\n" + ] + } + ], + "source": [ + "# target = 'nvidia'\n", + "!python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia --M 25" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we want to push the simulation to an $N=34$ coreset, a single GPU (assuming A100) will run out of memory. Run the code below to see for yourself. " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using BFL2 method to generate coresets\n", + "RuntimeError: NLOpt runtime error: nlopt failure\n" + ] + } + ], + "source": [ + "# target = 'nvidia'\n", + "!python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia --M 34" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To compute a problem with 34 qubits, we need to pool the memory of multiple GPUs. If you have multiple GPUs available, try the code below to run the same computation on 4 GPUs. You do not need to wait for the code to finish, just note how it does not fail immediately due to memory issues." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using BFL2 method to generate coresets\n", + "Using BFL2 method to generate coresets\n", + "Using BFL2 method to generate coresets\n", + "Using BFL2 method to generate coresets\n", + "^C\n" + ] + } + ], + "source": [ + "# target = 'nvidia-mgpu'\n", + "gpu_count = !nvidia-smi -L | wc -l\n", + "try:\n", + " gpu_count = int(gpu_count[0])\n", + "except:\n", + " gpu_count = 0 \n", + "if gpu_count >= 4:\n", + " !mpirun -np 4 python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia-mgpu --M 34\n", + "else:\n", + " print(f'Not enough GPUs found on this system ({gpu_count}) to run this step')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/pr-2023/examples/python/tutorials/cost_minimization.html b/pr-2023/examples/python/tutorials/cost_minimization.html index f8e4719266..a8daf969ba 100644 --- a/pr-2023/examples/python/tutorials/cost_minimization.html +++ b/pr-2023/examples/python/tutorials/cost_minimization.html @@ -127,7 +127,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -320,8 +333,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -506,6 +525,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/examples/python/tutorials/deutschs_algorithm.html b/pr-2023/examples/python/tutorials/deutschs_algorithm.html index e134afe2cd..b8cad88afb 100644 --- a/pr-2023/examples/python/tutorials/deutschs_algorithm.html +++ b/pr-2023/examples/python/tutorials/deutschs_algorithm.html @@ -127,7 +127,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -320,8 +333,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -506,6 +525,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • @@ -619,7 +639,7 @@

    XOR \(\oplus\)

    Quantum oracles

    -

    2e4f10f65feb47aa9815edc204ab1527

    +

    add4d85cb94e430a97ad8acc853ab9fe

    Suppose we have \(f(x): \{0,1\} \longrightarrow \{0,1\}\). We can compute this function on a quantum computer using oracles which we treat as black box functions that yield the output with an appropriate sequence of logic gates.

    Above you see an oracle represented as \(U_f\) which allows us to transform the state \(\ket{x}\ket{y}\) into:

    @@ -667,7 +687,7 @@

    Quantum parallelism

    Our aim is to find out if \(f: \{0,1\} \longrightarrow \{0,1\}\) is a constant or a balanced function? If constant, \(f(0) = f(1)\), and if balanced, \(f(0) \neq f(1)\).

    We step through the circuit diagram below and follow the math after the application of each gate.

    -

    3061cb6a58d54a789f4da47d081bbdaa

    +

    6e77838f10a0467d8f6c240c382e7d9d

    \[\ket{\psi_0} = \ket{01} \tag{1}\]
    diff --git a/pr-2023/examples/python/tutorials/hadamard_test.html b/pr-2023/examples/python/tutorials/hadamard_test.html index b49ca6cb95..ada204cb38 100644 --- a/pr-2023/examples/python/tutorials/hadamard_test.html +++ b/pr-2023/examples/python/tutorials/hadamard_test.html @@ -127,7 +127,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -320,8 +333,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -506,6 +525,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/examples/python/tutorials/hybrid_qnns.html b/pr-2023/examples/python/tutorials/hybrid_qnns.html index 61529c9565..8f1a44334e 100644 --- a/pr-2023/examples/python/tutorials/hybrid_qnns.html +++ b/pr-2023/examples/python/tutorials/hybrid_qnns.html @@ -127,7 +127,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -320,8 +333,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -506,6 +525,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/examples/python/tutorials/maximum_vertex_weight_clique.html b/pr-2023/examples/python/tutorials/maximum_vertex_weight_clique.html index 31ed5c43bf..5708b54930 100644 --- a/pr-2023/examples/python/tutorials/maximum_vertex_weight_clique.html +++ b/pr-2023/examples/python/tutorials/maximum_vertex_weight_clique.html @@ -127,7 +127,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -320,8 +333,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -506,6 +525,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/examples/python/tutorials/noisy_simulations.html b/pr-2023/examples/python/tutorials/noisy_simulations.html index e6cb6cceb3..6de3d56544 100644 --- a/pr-2023/examples/python/tutorials/noisy_simulations.html +++ b/pr-2023/examples/python/tutorials/noisy_simulations.html @@ -127,7 +127,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -320,8 +333,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -506,6 +525,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/examples/python/tutorials/qaoa.html b/pr-2023/examples/python/tutorials/qaoa.html index 0da4bf778c..7634c3ff5e 100644 --- a/pr-2023/examples/python/tutorials/qaoa.html +++ b/pr-2023/examples/python/tutorials/qaoa.html @@ -127,7 +127,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -320,8 +333,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -506,6 +525,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/examples/python/tutorials/quantum_fourier_transform.html b/pr-2023/examples/python/tutorials/quantum_fourier_transform.html index 3584698073..510826f18c 100644 --- a/pr-2023/examples/python/tutorials/quantum_fourier_transform.html +++ b/pr-2023/examples/python/tutorials/quantum_fourier_transform.html @@ -127,7 +127,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -320,8 +333,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -506,6 +525,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/examples/python/tutorials/readout_error_mitigation.html b/pr-2023/examples/python/tutorials/readout_error_mitigation.html index 8d563ee84f..f5420861c8 100644 --- a/pr-2023/examples/python/tutorials/readout_error_mitigation.html +++ b/pr-2023/examples/python/tutorials/readout_error_mitigation.html @@ -127,7 +127,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -320,8 +333,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -506,6 +525,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • @@ -543,7 +563,7 @@

    Readout Error Mitigation

    -

    Readout errors are caused by imperfect qubit measurement and are a common source of error in quantum computing. Properly modelling these errors in simulation can give the user tools to understand better how these errors are and how to mitigate them when running on actual quantum devices.

    +

    Readout errors are caused by imperfect qubit measurement and are a common source of error in quantum computing. Properly modelling these errors in simulation can give the user tools to understand better what these errors are and how to mitigate them when running on actual quantum devices.

    Readout errors can be mitigated with a confusion matrix \(A\). It is a square matrix of size \(2^n \times 2^n\) and tells about the probability of observing the state \(|y\rangle\) given the true state \(|x\rangle\). The confusion matrix characterizes the readout error of the device and is circuit-independent. Once \(A\) is estimated, we can compute its pseudoinverse \(A^+\) which can be applied to the noisy probability distribution \(p_{\text{noisy}}\) to obtain an adjusted quasi-probability distribution

    @@ -551,7 +571,7 @@

    Readout Error Mitigation

  • Using a single qubit model

    • -

  • using \(k\) local confusion matrices

    • +

  • Using \(k\) local confusion matrices

  • A full confusion matrix for each \(2^n\) combination

    • The last method works well for correcting correlated errors (which affect multiple qubits together). However, it becomes impractical for large numbers of qubits.

    @@ -593,7 +613,7 @@

    Readout Error Mitigationprobs can be the same or different for all the qubits.

    -

    Note: In principle, readout error is applied to the measurement gate but we use Identity gate as adding a quantum error on the measurement gate is not yet supported. Also, the Identity gate is not present in the add_channel method, so we model the Identity gate using a rotation gate with an angle of 0.0.

    +

    Note: In principle, readout error is applied to the measurement gate but we use the Identity gate because adding a quantum error on the measurement gate is not yet supported. Also, the Identity gate is not present in the add_channel method, so we model the Identity gate using a rotation gate with an angle of 0.0.

    [3]:
    @@ -624,7 +644,7 @@

    Readout Error Mitigation\(n\) qubits. It takes the number of qubits and the basis state as arguments.

    +

    We define a cudaq kernel which will help create a set of quantum circuits to take measurements of the basis states for \(n\) qubits. The kernel takes the number of qubits and the basis state as arguments.

    [4]:
    @@ -642,7 +662,7 @@

    Readout Error Mitigation \[\frac{|000\rangle + |111\rangle}{\sqrt{2}}\]

    @@ -657,7 +677,7 @@

    Readout Error Mitigationfor i in range(n_qubits - 1): cx(qvector[i], qvector[i + 1]) - # Apply id gates for readout error mitigation + # Apply identity gates for readout error mitigation for i in range(n_qubits): rx(0.0, qvector[i]) @@ -687,7 +707,7 @@

    Readout Error Mitigation\(p_{\text{mitigated}}\) obtained by application of \(A^+\) to \(p_{\text{noisy}}\) can be possibly non-positive. We need to find the closest positive probability distribution in such a case.

    +

    It is possible that the adjusted quasi-probability distribution \(p_{\text{mitigated}}\) obtained by application of \(A^+\) to \(p_{\text{noisy}}\) may be non-positive. We need to find the closest positive probability distribution in such a case.

    \[p'' = \min_{p_{\rm positive}} \|p_{\rm noisy} - p_{\rm positive}\|_1\]

    Then, we can draw samples from \(p''\).

    @@ -854,13 +874,13 @@

    Readout Error Mitigation

    Inverse confusion matrix from single-qubit noise model

    -

    Here we assume that the readout error of each qubit is independent and with the same confusion probabilities. Then, the confusion matrix \(A_1\) for a single qubit can be defined as

    +

    Here we assume that the readout error of each qubit is independent with the same confusion probabilities. Then, the confusion matrix \(A_1\) for a single qubit can be defined as

    \[\begin{split}A_1 = \begin{bmatrix} P(0|0) & P(0|1)\\ P(1|0) & P(1|1) \end{bmatrix}\end{split}\]
    -

    where \(P(y|x)\) is the probability of observing state \(|y\rangle\) when measuring true state \(|x\rangle\). Using \(A_1\) the full \(2^n \times 2^n\) confusion matrix \(A\) can be written as

    +

    where \(P(y|x)\) is the probability of observing state \(|y\rangle\) when measuring the true state \(|x\rangle\). Using \(A_1\), the full \(2^n \times 2^n\) confusion matrix \(A\) can be written as

    \[A = A_1 \otimes \dots \otimes A_1\]
    @@ -1125,7 +1145,7 @@

    Inverse confusion matrix from k local confusion matrices

    Inverse of full confusion matrix

    -

    Here we generate a quantum circuit for each of the basis states of \(n\) qubits i.e. \(2^n\) combinations. This gives more accurate readout error mitigation. Since it scales exponentially with the number of qubits, it is only practical for small devices.

    +

    Here we generate a quantum circuit for each of the basis states of \(n\) qubits (i.e., \(2^n\) combinations). This gives more accurate readout error mitigation. Since it scales exponentially with the number of qubits, it is only practical for small devices.

    [21]:
    diff --git a/pr-2023/examples/python/tutorials/readout_error_mitigation.ipynb b/pr-2023/examples/python/tutorials/readout_error_mitigation.ipynb index cec9dea413..1d1fee4095 100644 --- a/pr-2023/examples/python/tutorials/readout_error_mitigation.ipynb +++ b/pr-2023/examples/python/tutorials/readout_error_mitigation.ipynb @@ -7,7 +7,7 @@ "source": [ "# Readout Error Mitigation\n", "\n", - "Readout errors are caused by imperfect qubit measurement and are a common source of error in quantum computing. Properly modelling these errors in simulation can give the user tools to understand better how these errors are and how to mitigate them when running on actual quantum devices.\n", + "Readout errors are caused by imperfect qubit measurement and are a common source of error in quantum computing. Properly modelling these errors in simulation can give the user tools to understand better what these errors are and how to mitigate them when running on actual quantum devices.\n", "\n", "Readout errors can be mitigated with a confusion matrix $A$. It is a square matrix of size $2^n \\times 2^n$ and tells about the probability of observing the state $|y\\rangle$ given the true state $|x\\rangle$. The confusion matrix characterizes the readout error of the device and is circuit-independent. Once $A$ is estimated, we can compute its pseudoinverse $A^+$ which can be applied to the noisy probability distribution $p_{\\text{noisy}}$ to obtain an adjusted quasi-probability distribution \n", "\n", @@ -18,7 +18,7 @@ "In this tutorial, we show how to build a confusion matrix with the following approaches.\n", "\n", "- Using a single qubit model\n", - "- using $k$ local confusion matrices\n", + "- Using $k$ local confusion matrices\n", "- A full confusion matrix for each $2^n$ combination\n", "\n", "The last method works well for correcting correlated errors (which affect multiple qubits together). However, it becomes impractical for large numbers of qubits." @@ -73,7 +73,7 @@ "To model the readout error, we apply a bitflip channel on every qubit at the end of the circuit using an Identity gate. The probability of bitflip `probs` can be the same or different for all the qubits.\n", "\n", "
    Note: \n", - "In principle, readout error is applied to the measurement gate but we use Identity gate as adding a quantum error on the measurement gate is not yet supported. Also, the Identity gate is not present in the add_channel method, so we model the Identity gate using a rotation gate with an angle of 0.0.\n", + "In principle, readout error is applied to the measurement gate but we use the Identity gate because adding a quantum error on the measurement gate is not yet supported. Also, the Identity gate is not present in the add_channel method, so we model the Identity gate using a rotation gate with an angle of 0.0.\n", "
    " ] }, @@ -114,7 +114,7 @@ "id": "bb4c7a14-1c0c-4fab-a6aa-7174c23baa7f", "metadata": {}, "source": [ - "We define a cudaq kernel which will help create a set of quantum circuits to take measurements of the basis states for $n$ qubits. It takes the number of qubits and the basis state as arguments." + "We define a cudaq kernel which will help create a set of quantum circuits to take measurements of the basis states for $n$ qubits. The kernel takes the number of qubits and the basis state as arguments." ] }, { @@ -141,7 +141,7 @@ "id": "95411463-cd1e-499f-baef-d624acc0122c", "metadata": {}, "source": [ - "For the tutorial, we will use GHZ state on three qubits for testing readout error mitigation. The GHZ state on 3 qubits is described as:\n", + "For the tutorial, we will use the GHZ state on three qubits to test readout error mitigation. The GHZ state on 3 qubits is described as:\n", "\n", "$$\n", "\\frac{|000\\rangle + |111\\rangle}{\\sqrt{2}}\n", @@ -163,7 +163,7 @@ " for i in range(n_qubits - 1):\n", " cx(qvector[i], qvector[i + 1])\n", "\n", - " # Apply id gates for readout error mitigation\n", + " # Apply identity gates for readout error mitigation\n", " for i in range(n_qubits):\n", " rx(0.0, qvector[i])\n", "\n", @@ -199,7 +199,7 @@ "id": "032f6898-c953-4d30-a2bf-e8b46ee77c62", "metadata": {}, "source": [ - "It is possible that the adjusted quasi-probability distribution $p_{\\text{mitigated}}$ obtained by application of $A^+$ to $p_{\\text{noisy}}$ can be possibly non-positive. We need to find the closest positive probability distribution in such a case.\n", + "It is possible that the adjusted quasi-probability distribution $p_{\\text{mitigated}}$ obtained by application of $A^+$ to $p_{\\text{noisy}}$ may be non-positive. We need to find the closest positive probability distribution in such a case.\n", "\n", " $$ p'' = \\min_{p_{\\rm positive}} \\|p_{\\rm noisy} - p_{\\rm positive}\\|_1$$\n", "\n", @@ -393,7 +393,7 @@ "source": [ "## Inverse confusion matrix from single-qubit noise model\n", "\n", - "Here we assume that the readout error of each qubit is independent and with the same confusion probabilities. Then, the confusion matrix $A_1$ for a single qubit can be defined as\n", + "Here we assume that the readout error of each qubit is independent with the same confusion probabilities. Then, the confusion matrix $A_1$ for a single qubit can be defined as\n", "\n", "$$\n", "A_1 = \\begin{bmatrix}\n", @@ -402,7 +402,7 @@ "\\end{bmatrix}\n", "$$\n", "\n", - "where $P(y|x)$ is the probability of observing state $|y\\rangle$ when measuring true state $|x\\rangle$. Using $A_1$ the full $2^n \\times 2^n$ confusion matrix $A$ can be written as \n", + "where $P(y|x)$ is the probability of observing state $|y\\rangle$ when measuring the true state $|x\\rangle$. Using $A_1$, the full $2^n \\times 2^n$ confusion matrix $A$ can be written as \n", "\n", "$$\n", "A = A_1 \\otimes \\dots \\otimes A_1\n", @@ -719,7 +719,7 @@ "source": [ "## Inverse of full confusion matrix\n", "\n", - "Here we generate a quantum circuit for each of the basis states of $n$ qubits i.e. $2^n$ combinations. This gives more accurate readout error mitigation. Since it scales exponentially with the number of qubits, it is only practical for small devices." + "Here we generate a quantum circuit for each of the basis states of $n$ qubits (i.e., $2^n$ combinations). This gives more accurate readout error mitigation. Since it scales exponentially with the number of qubits, it is only practical for small devices." ] }, { diff --git a/pr-2023/examples/python/tutorials/visualization.html b/pr-2023/examples/python/tutorials/visualization.html new file mode 100644 index 0000000000..18a1ef8e5f --- /dev/null +++ b/pr-2023/examples/python/tutorials/visualization.html @@ -0,0 +1,888 @@ + + + + + + + Visualization — NVIDIA CUDA-Q documentation + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + +
    + +
    +
    +
    + +
    +
    +
    +
    + +
    +

    Visualization

    +
    +

    Qubit Visualization

    +

    What are the possible states a qubit can be in and how can we build up a visual cue to help us make sense of quantum states and their evolution?

    +

    We know our qubit can have two distinct states: \(\ket{0}\) and \(\ket{1}\). Maybe we need a one-dimensional line whose vertices can represent each of the states. We also know that qubits can be in an equal superposition states: \(\ket{+}\) and \(\ket{-}\). This now forces us to extend our 1D line to a 2D Cartesian coordinate system. If you dive deeper you will learn about the existence of states like \(\ket{+i}\) and \(\ket{-i}\), this calls for a 3D extension.

    +

    It turns out that a sphere is able to depict all the possible states of a single qubit. This is called a Bloch sphere.

    +

    Bloch Sphere

    +

    Let us try to showcase the functionality to render such a 3D representation with CUDA-Q. First, let us define a single-qubit kernel that returns a different state each time. This kernel uses random rotations.

    +

    Note: CUDA-Q uses the QuTiP library to render Bloch spheres. The following code will throw an error if QuTiP is not installed.

    +
    +
    [1]:
+
    +
    +
    # install `qutip` in the current Python kernel. Skip this if `qutip` is already installed.
+# `matplotlib` is required for all visualization tasks.
+# Make sure to restart your kernel if you execute this!
+# In a Jupyter notebook, go to the menu bar > Kernel > Restart Kernel.
+# In VSCode, click on the Restart button in the Jupyter toolbar.
+
+# The '\' before the '>' operator is so that the shell does not misunderstand
+# the '>' qualifier for the bash pipe operation.
+
+import sys
+
+try:
+    import matplotlib.pyplot as plt
+    import qutip
+
+except ImportError:
+    print("Tools not found, installing. Please restart your kernel after this is done.")
+    !{sys.executable} -m pip install qutip\>=5 matplotlib\>=3.5
+    print("\nNew libraries have been installed. Please restart your kernel!")
+
    +
    +
    +
    +
    +
    +
    +
    +Tools not found, installing. Please restart your kernel after this is done.
+Collecting qutip>=5
+  Downloading qutip-5.0.3.post1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (28.0 MB)
+     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 28.0/28.0 MB 41.1 MB/s eta 0:00:00
+Requirement already satisfied: matplotlib>=3.5 in /usr/local/lib/python3.10/dist-packages (3.9.1)
+Requirement already satisfied: scipy>=1.9 in /usr/local/lib/python3.10/dist-packages (from qutip>=5) (1.10.1)
+Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from qutip>=5) (24.1)
+Requirement already satisfied: numpy>=1.22 in /usr/local/lib/python3.10/dist-packages (from qutip>=5) (1.26.4)
+Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.5) (1.4.5)
+Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.5) (1.2.1)
+Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.5) (0.12.1)
+Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.5) (2.9.0.post0)
+Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.5) (10.4.0)
+Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.5) (3.1.2)
+Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.5) (4.53.1)
+Requirement already satisfied: six>=1.5 in /usr/lib/python3/dist-packages (from python-dateutil>=2.7->matplotlib>=3.5) (1.16.0)
+Installing collected packages: qutip
+Successfully installed qutip-5.0.3.post1
+WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
+
+New libraries have been installed. Please restart your kernel!
+
    +
    +
    +
    [2]:
+
    +
    +
    import cudaq
+import numpy as np
+
+## Retry the subsequent cells by setting the target to density matrix simulator.
+# cudaq.set_target("density-matrix-cpu")
+
+
+@cudaq.kernel
+def kernel(angles: np.ndarray):
+    qubit = cudaq.qubit()
+    rz(angles[0], qubit)
+    rx(angles[1], qubit)
+    rz(angles[2], qubit)
+
    +
    +
    +

    Next, we instantiate a random number generator, so we can get random outputs. We then create 4 random single-qubit states by using cudaq.add_to_bloch_sphere() on the output state obtained from the random kernel.

    +
    +
    [3]:
+
    +
    +
    rng = np.random.default_rng(seed=11)
+blochSphereList = []
+for _ in range(4):
+    angleList = rng.random(3) * 2 * np.pi
+    sph = cudaq.add_to_bloch_sphere(cudaq.get_state(kernel, angleList))
+    blochSphereList.append(sph)
+
    +
    +
    +

    We can display the spheres with cudaq.show(). Show the first sphere:

    +
    +
    [4]:
+
    +
    +
    cudaq.show(blochSphereList[0])
+
    +
    +
    +
    +
    +
    +
    +../../../_images/examples_python_tutorials_visualization_7_0.png +
    +
    +

    We can also show multiple Bloch spheres side by side - simply set the nrows and ncols in the call to cudaq.show() accordingly. Make sure to have more spaces than spheres in your list, else it will throw an error! Let us show two spheres in a row:

    +
    +
    [5]:
+
    +
    +
    cudaq.show(blochSphereList[:2], nrows=1, ncols=2)
+
    +
    +
    +
    +
    +
    +
    +../../../_images/examples_python_tutorials_visualization_9_0.png +
    +
    +

    We can show them in a column too, if we want! Simply set the nrows = 2 and ncols = 1.

    +
    +
    [6]:
+
    +
    +
    cudaq.show(blochSphereList[:2], nrows=2, ncols=1)
+
    +
    +
    +
    +
    +
    +
    +../../../_images/examples_python_tutorials_visualization_11_0.png +
    +
    +

    Can we show the entire list of 4 Bloch spheres we created? Absolutely!

    +
    +
    [7]:
+
    +
    +
    cudaq.show(blochSphereList[:], nrows=2, ncols=2)
+
    +
    +
    +
    +
    +
    +
    +../../../_images/examples_python_tutorials_visualization_13_0.png +
    +
    +

    What if we had to add multiple vectors to a single Bloch sphere? CUDA-Q uses the QuTiP toolbox to construct Bloch spheres. We can then add multiple states to the same Bloch sphere by passing the sphere object as an argument to cudaq.add_to_bloch_sphere().

    +
    +
    [8]:
+
    +
    +
    import qutip
+
+rng = np.random.default_rng(seed=47)
+blochSphere = qutip.Bloch()
+for _ in range(10):
+    angleList = rng.random(3) * 2 * np.pi
+    sph = cudaq.add_to_bloch_sphere(cudaq.get_state(kernel, angleList), blochSphere)
+
    +
    +
    +

    This created a single Bloch sphere with 10 random vectors. Let us see how it looks.

    +
    +
    [9]:
+
    +
    +
    blochSphere.show()
+
    +
    +
    +
    +
    +
    +
    +../../../_images/examples_python_tutorials_visualization_17_0.png +
    +
    +

    Unfortunately, there is no such handy visualization for multi-qubit states. In particular, a multi-qubit state cannot be visualized as multiple Bloch spheres due to the nature of entanglement that makes quantum computing so powerful.

    +
    +
    +

    Kernel Visualization

    +

    A CUDA-Q kernel can be visualized using the cudaq.draw API which returns a string representing the drawing of the execution path, in the specified format. ASCII (default) and LaTeX formats are supported.

    +
    +
    [10]:
+
    +
    +
    @cudaq.kernel
+def kernel_to_draw():
+    q = cudaq.qvector(4)
+    h(q)
+    x.ctrl(q[0], q[1])
+    y.ctrl([q[0], q[1]], q[2])
+    z(q[2])
+
+    swap(q[0], q[1])
+    swap(q[0], q[3])
+    swap(q[1], q[2])
+
+    r1(3.14159, q[0])
+    tdg(q[1])
+    s(q[2])
+
    +
    +
    +
    +
    [11]:
+
    +
    +
    print(cudaq.draw(kernel_to_draw))
+
    +
    +
    +
    +
    +
    +
    +
    +     ╭───╮                  ╭───────────╮
+q0 : ┤ h ├──●────●────╳───╳─┤ r1(3.142) ├───────
+     ├───┤╭─┴─╮  │    │   │ ╰───────────╯╭─────╮
+q1 : ┤ h ├┤ x ├──●────╳───┼───────╳──────┤ tdg ├
+     ├───┤╰───╯╭─┴─╮╭───╮ │       │      ╰┬───┬╯
+q2 : ┤ h ├─────┤ y ├┤ z ├─┼───────╳───────┤ s ├─
+     ├───┤     ╰───╯╰───╯ │               ╰───╯
+q3 : ┤ h ├────────────────╳─────────────────────
+     ╰───╯
+
+
    +
    +
    +
    [12]:
+
    +
    +
    print(cudaq.draw('latex', kernel_to_draw))
+
    +
    +
    +
    +
    +
    +
    +
    +\documentclass{minimal}
+\usepackage{quantikz}
+\begin{document}
+\begin{quantikz}
+  \lstick{$q_0$} & \gate{H} & \ctrl{1} & \ctrl{2} & \swap{1} & \swap{3} & \gate{R_1(3.142)} & \qw & \qw \\
+  \lstick{$q_1$} & \gate{H} & \gate{X} & \ctrl{1} & \targX{} & \qw & \swap{1} & \gate{T^\dag} & \qw \\
+  \lstick{$q_2$} & \gate{H} & \qw & \gate{Y} & \gate{Z} & \qw & \targX{} & \gate{S} & \qw \\
+  \lstick{$q_3$} & \gate{H} & \qw & \qw & \qw & \targX{} & \qw & \qw & \qw \\
+\end{quantikz}
+\end{document}
+
+
    +
    +

    Copy this output string into any LaTeX editor and export it to PDF.

    +

    Circuit in PDF format

    +
    +
    + + +
    +
    + +
    +
    +
    +
    + + + + + + + \ No newline at end of file diff --git a/pr-2023/examples/python/tutorials/visualization.ipynb b/pr-2023/examples/python/tutorials/visualization.ipynb new file mode 100644 index 0000000000..1e62d68957 --- /dev/null +++ b/pr-2023/examples/python/tutorials/visualization.ipynb @@ -0,0 +1,603 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualization\n", + "\n", + "## Qubit Visualization\n", + "\n", + "What are the possible states a qubit can be in and how can we build up a visual cue to help us make sense of quantum states and their evolution?\n", + "\n", + "We know our qubit can have two distinct states: $\\ket{0}$ and $\\ket{1}$. Maybe we need a one-dimensional line whose vertices can\n", + "represent each of the states. We also know that qubits can be in an equal superposition states: $\\ket{+}$ and $\\ket{-}$. This now forces us to extend our 1D line to a 2D Cartesian coordinate system. If you dive deeper you will learn about the existence of states like \n", + "$\\ket{+i}$ and $\\ket{-i}$, this calls for a 3D extension.\n", + "\n", + "It turns out that a sphere is able to depict all the possible states of a single qubit. This is called a Bloch sphere. \n", + "\n", + "\"Bloch\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us try to showcase the functionality to render such a 3D representation with CUDA-Q. \n", + "First, let us define a single-qubit kernel that returns a different state each time. This kernel uses random rotations.\n", + "\n", + "Note: CUDA-Q uses the [QuTiP](https://qutip.org) library to render Bloch spheres. The following code will throw an error if QuTiP is not installed. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2024-08-12T15:07:09.167387Z", + "iopub.status.busy": "2024-08-12T15:07:09.167170Z", + "iopub.status.idle": "2024-08-12T15:07:12.036592Z", + "shell.execute_reply": "2024-08-12T15:07:12.035390Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tools not found, installing. Please restart your kernel after this is done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting qutip>=5\r\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Downloading qutip-5.0.3.post1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (28.0 MB)\r\n", + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/28.0 MB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.3/28.0 MB\u001b[0m \u001b[31m10.3 MB/s\u001b[0m eta \u001b[36m0:00:03\u001b[0m" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "\u001b[2K \u001b[91m━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.0/28.0 MB\u001b[0m \u001b[31m73.1 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m11.8/28.0 MB\u001b[0m \u001b[31m209.3 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r", + "\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━\u001b[0m \u001b[32m23.1/28.0 MB\u001b[0m \u001b[31m334.1 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━\u001b[0m \u001b[32m23.1/28.0 MB\u001b[0m \u001b[31m334.1 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━\u001b[0m \u001b[32m23.1/28.0 MB\u001b[0m \u001b[31m334.1 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r", + "\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━\u001b[0m \u001b[32m25.2/28.0 MB\u001b[0m \u001b[31m86.3 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m28.0/28.0 MB\u001b[0m \u001b[31m71.0 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m28.0/28.0 MB\u001b[0m \u001b[31m71.0 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + "\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m28.0/28.0 MB\u001b[0m \u001b[31m71.0 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m28.0/28.0 MB\u001b[0m \u001b[31m41.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\r\n", + "\u001b[?25hRequirement already satisfied: matplotlib>=3.5 in /usr/local/lib/python3.10/dist-packages (3.9.1)\r\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: scipy>=1.9 in /usr/local/lib/python3.10/dist-packages (from qutip>=5) (1.10.1)\r\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from qutip>=5) (24.1)\r\n", + "Requirement already satisfied: numpy>=1.22 in /usr/local/lib/python3.10/dist-packages (from qutip>=5) (1.26.4)\r\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.5) (1.4.5)\r\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.5) (1.2.1)\r\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.5) (0.12.1)\r\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.5) (2.9.0.post0)\r\n", + "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.5) (10.4.0)\r\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.5) (3.1.2)\r\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.5) (4.53.1)\r\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: six>=1.5 in /usr/lib/python3/dist-packages (from python-dateutil>=2.7->matplotlib>=3.5) (1.16.0)\r\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installing collected packages: qutip\r\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Successfully installed qutip-5.0.3.post1\r\n", + "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\r\n", + "\u001b[0m" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "New libraries have been installed. Please restart your kernel!\n" + ] + } + ], + "source": [ + "# install `qutip` in the current Python kernel. Skip this if `qutip` is already installed.\n", + "# `matplotlib` is required for all visualization tasks.\n", + "# Make sure to restart your kernel if you execute this!\n", + "# In a Jupyter notebook, go to the menu bar > Kernel > Restart Kernel.\n", + "# In VSCode, click on the Restart button in the Jupyter toolbar.\n", + "\n", + "# The '\\' before the '>' operator is so that the shell does not misunderstand\n", + "# the '>' qualifier for the bash pipe operation.\n", + "\n", + "import sys\n", + "\n", + "try:\n", + " import matplotlib.pyplot as plt\n", + " import qutip\n", + "\n", + "except ImportError:\n", + " print(\"Tools not found, installing. Please restart your kernel after this is done.\")\n", + " !{sys.executable} -m pip install qutip\\>=5 matplotlib\\>=3.5\n", + " print(\"\\nNew libraries have been installed. Please restart your kernel!\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2024-08-12T15:07:12.039943Z", + "iopub.status.busy": "2024-08-12T15:07:12.039631Z", + "iopub.status.idle": "2024-08-12T15:07:13.236584Z", + "shell.execute_reply": "2024-08-12T15:07:13.235587Z" + } + }, + "outputs": [], + "source": [ + "import cudaq\n", + "import numpy as np\n", + "\n", + "## Retry the subsequent cells by setting the target to density matrix simulator.\n", + "# cudaq.set_target(\"density-matrix-cpu\")\n", + "\n", + "\n", + "@cudaq.kernel\n", + "def kernel(angles: np.ndarray):\n", + " qubit = cudaq.qubit()\n", + " rz(angles[0], qubit)\n", + " rx(angles[1], qubit)\n", + " rz(angles[2], qubit)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we instantiate a random number generator, so we can get random outputs. We then create 4 random single-qubit states by using `cudaq.add_to_bloch_sphere()` on the output state obtained from the random kernel." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2024-08-12T15:07:13.240098Z", + "iopub.status.busy": "2024-08-12T15:07:13.239836Z", + "iopub.status.idle": "2024-08-12T15:07:13.402113Z", + "shell.execute_reply": "2024-08-12T15:07:13.401407Z" + } + }, + "outputs": [], + "source": [ + "rng = np.random.default_rng(seed=11)\n", + "blochSphereList = []\n", + "for _ in range(4):\n", + " angleList = rng.random(3) * 2 * np.pi\n", + " sph = cudaq.add_to_bloch_sphere(cudaq.get_state(kernel, angleList))\n", + " blochSphereList.append(sph)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can display the spheres with `cudaq.show()`. Show the first sphere:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2024-08-12T15:07:13.405042Z", + "iopub.status.busy": "2024-08-12T15:07:13.404563Z", + "iopub.status.idle": "2024-08-12T15:07:13.624162Z", + "shell.execute_reply": "2024-08-12T15:07:13.623495Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgcAAAIHCAYAAAALof87AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9R4wkSZodjj9zFR46UlWKrqquqq6urmrd03p6emdmZ3/LA7FcEgTBy4IEQfBEAnvY257IAy8k9rAATwsQBHgiLwQFFuR/Z2d3dkT3dPe0VqUzS2aJFKFcu5v9D25m6REZwkNlZXb5AxKpIlyFu9mz73vf+whjjCFDhgwZMmTIkIFDedQHkCFDhgwZMmQ4XMjIQYYMGTJkyJChAxk5yJAhQ4YMGTJ0ICMHGTJkyJAhQ4YOZOQgQ4YMGTJkyNCBjBxkyJAhQ4YMGTqQkYMMGTJkyJAhQwcycpAhQ4YMGTJk6EBGDjJkyNCBGzdu4E/+5E9w/vx5FItFzM/P4/XXX8d//I//EbZtD3zvP//n/xyEEPyjf/SPDuhoM2TIMAuQzCExQ4bHB//23/5b/Lt/9++wvr6OU6dO7fv///k//wd/9Ed/hGaz2fP9586dw1/+5V/i7NmzPf//P/7H/8A//sf/GMViEVtbWzBNc5qHnyFDhgNCFjnIkCEDAODTTz/FP/2n/xTNZhOlUgn//t//e7z33nv42c9+hn/1r/4VAODy5cv4+3//76PVavXcxt/7e38PuVwOlmXhZz/72UEefoYMGaaIjBxkyJABAPDHf/zHcBwHmqbhr/7qr/Cnf/qnePvtt/G7v/u7+Iu/+Av8h//wHwDEBOHP/uzPem6jWCziJz/5CQDgf//v/31gx54hQ4bpIiMHGTJkwIcffohf/vKXAIB/+S//Jd5+++19r/mTP/kTXLhwAQDw53/+5wiCoOe2/sE/+AcA4hRFlrXMkOFoIiMHGTJkwP/8n/9T/vwv/sW/6PkaRVHwz/7ZPwMA1Ot1/O3f/m3P1/3BH/wBCCHY3NzERx99NPVjzZAhw+yRkYMMGTLgV7/6FYA4LfDqq6/2fd0Pf/hD+fOvf/3rnq9ZW1vD66+/DiBLLWTIcFSRkYMMGTLg22+/BQCcPXsWmqb1fd358+f3vacXRGohIwcZMhxNZOQgQ4bHHK7rYmtrCwBw/Pjxga+dm5tDsVgEANy6davv6/7wD/8QAPDll19ifX19SkeaIUOGg0JGDjJkeMyRLEsslUpDXy/IQbvd7vua559/HmfOnAGQRQ8yZDiKyMhBhgyPOVzXlT8bhjH09blcDgDgOM7A12WphQwZji4ycpAhw2OOpIuh7/tDX+95HgAgn88PfJ1ILfziF79AvV4f/wAzZMhw4MjIQYYMjznK5bL8eVCqQMCyLADDUxBvvvkmCCEIwxC//e1vJzvIDBkyHCgycpAhw2MO0zSxsLAAALh9+/bA1+7u7kpycOLEiYGv/dWvfgXGGAzDwJtvvjmdg82QIcOBICMHGTJkwLPPPgsAuHr1KsIw7Pu6ixcvyp+FW2I//K//9b8AAD/+8Y87ohMZMmQ4/MjIQYYMGfCDH/wAQJwy+Pjjj/u+7u/+7u/kz++8887Abf6f//N/AOwJEzNkyHB0kJGDDBky4B/+w38of/4v/+W/9HwNpRT/9b/+VwBArVbDj3/8477b+/TTT3Hz5k0AGTnIkOEoIiMHGTJkwBtvvIF3330XAPCf//N/xvvvv7/vNX/2Z38mXRH/+I//GLqu992eSCm88sorQ42VMmTIcPjQ3yc1Q4YMjxX+/M//HO+88w4cx8Hv//7v40//9E/x4x//GI7j4L/9t/+Gv/iLvwAAnDt3Dn/yJ38ycFvC20CUM2bIkOFoISMHGTJkABCv8v/7f//v+KM/+iM0m0386Z/+6b7XnDt3Dn/5l385UGB469YtfPrppwCylEKGDEcVGTnIkOExwo9+9CMAsWagF/7gD/4AX3zxBf78z/8cf/mXf4nbt2/DMAycPXsW/+Sf/BP8m3/zb1AoFAbuQ0QNTpw4gVdeeWWah58hQ4YDAmGMsUd9EBkyZPju4Pd///fx05/+FP/6X/9r/Kf/9J8e9eFkyJBhDGSCxAwZMkwNzWYTP//5zwFkKYUMGY4yMnKQIUOGqeH//t//iyAIUKlUZAojQ4YMRw+Z5iBDhgxTw9/8zd+gWq3iD//wD1N1eMyQIcPhRKY5yJAhQ4YMGTJ0IEsrZMiQIUOGDBk6kJGDDBkyZMiQIUMHMnKQIUOGDBkyZOhARg4yZMgwVQRBgDAMkcmZMmQ4usiqFTJkyNABSmnHd0YpGKUAISCEgCgKCACiKFCUvfUFYwy7u7twXRcAQAiBqqqoVCowTfPAzyNDhgzjI6tWyJDhO4IwDBEFARhjIIQgCkNElIKGIWgUgUYRojAEAwBKwRjb+xnx5M4YA3oMCQwAjaLeO+akodlqIQhDEEKgKAoYISAAVFXF4uIidMOAqqpQNA2qokDRNNAwhKrr0A2jg2hkyJDh0SIjBxkyHBHQKEIYBIiCAGEQwPc8sChCxL+Sk7p4rKf1eA8iB5RSNNtthJwYVEolaJoGSinato0gCKBpGqrlMgghcnuMMZDEdhRVhappUHUdmqZBMwzohgEjl4Om6/K9GTJkmD0ycpAhwyECpRSh74OGYUwExPcg2AvzixV+CohXMf7evq/rIhOMMdD4B3lcjFIQRQFjDIqYqAlBi0cMFEVBpVyGru1lK6MoQr3ZBGMMhUIBedPsGZnoh0gQCEKg63pMGHQdOicMuVwOWma2lCHD1JGRgwwZDhCUUoRhiDAM4TkOHNuOIwBcwCfC8KqiQFXVjvf2iwYwxkApBWUMjFL5c/JvEaUAY/Hvye0IEhD/AeizOhfph24EQQDLcUAIQalQgKaqchuKogCMydeARxUMXYeiKHH6gacgSOJ7MkIgIgz9wAC4jgPX82DZNjTDwOKxY1hZW0M5EanIkCHDaMgEiRkyTBmUUkRRJElAGIbwPQ+u48D3PFDf71Dzi+lLrvJ7kACFkHjS5XoC8X/aHUUQOoLk8STC9wNXAomJVKzWxffk/4RWgTEG1/MAADmuJ2D8GIA4agDwdIGqwg8CWLYNls937rdr8ieKAoULHxVCwAiB57pwbBs2J1Ttdhu2baNtWWBRJI9PbIkwBkXXUS6XUZmfx8LiIhaXlrC4uIiFhQXku48hQ4YMHcgiBxkyTAm+76PdbsNxHIS+H3+FIajvx2F5xJOukogMiNW1L0iE7yMIAgRhGFcJ8G1T8ZgmHldN0+JJWdPkJK6KiZWvxJMr8+RkTwApGBRko/t7Er0iB57noWVZAIBatRpP5Ik0BEn8HoQh6s0mAKBaLsvXiAgH4z8DgOM4uLu5iVarBce24bpuTIL4+ecLBRRME4ViEcViEaVSCeVSCaViEURV4do2rHYbrXYb7XZb/iy2EwEwcjnU5uZw4skn8dZbb6FarY7xiWfI8N1FRg4yZJgQnuehvrODdquF0PMQ+H48SasqNFWVq34CLuzjkYWI0r4iP/E6UCpz/5QxRLzKAIAsJ9RUFflcDrlcbl8qoh9Gfei7yQFjDPVGAxGlKOTzKCRW4gycYHQNLbv1OiJKUS6VkOvSCUSMYfPuXayvr+P+gwcwNA1zc3PIl0owczkUCwWY+Tz0XA5UVFz0QTcBE58FYyyONiRIw93NTTi+j2cuXMC7P/whlpaWRrwyGTJ8N5GRgwwZxgClFK16HfXtbTi2LUsE86YJwzDAKEUg0gpdlQTdIIqyN5EJQsEnNQbIVTXjq3EgLlv0fB+u50mBIgOQ03WYuRz0FOp+EclIMwB0kwPX89C2LCiEYK5W66hCACEgPc7Xsm04roucYaBcKsm/bWxsYH19Hb7vY35+HqdPn8YTTzwBLSFsFOmSpIaCcoIVRVEH4RoEhRBomhZfZ00DCMHNjQ1cvnQJjufh+IkTeO2NN/Dk6dPIZamHDI8xMnKQIUNKhL4Pz3HQqtfRbDTiKgJKEUYRdF2HqmlgUdRbQEcIND75JwWHMrWQgJzshZBwABhj8DlJ8MNQ/BEKITBTRhNGJQfJqEFRVCDw/fYTNAJxaqHRbIIB8BwHG+vruP/wIQxNw8mTJ3Hq9OlU4X1xbZLVFPKa8TRFB3ngP9M+11Lh0Z179+7h+vXrsCwLq6ureO6553DiySdRLJdRKJWgpIzKZMjwXUBGDjJkGIDQ8+BaFjzHgdVuo9lswueaAEppXE7XZeBDEOsBNE2Dzr+nCfdLIyLhUNjHkKjvsUYRPM/biybw7eV4yZ8xIJowbC9JcuC6Ltq2DUVRMFetxtoC/rpBsYq2ZeGbixdx984dRGGIxYUFnDp9GsefeAKqll4bHXIzpzAMEYSh9HkYeg48LRMlvCG6CQNjDDs7O7h37x4c28bc3ByeOXcOa088gVKphGK1inK1mjp9kyHDUUVGDjJk6AINQ7i2DbfdhmvbaLbbaDSbssKAKEq8KuekIEkEdE4E0pbQiYqDbiLAGAPlE96o5XiMMfhBANd1e0YTTNPs6UY4aCBIkoM6vxYiaiDSE70gtQTXr+PB1hZUVcXy8jJOnTqF1ZWVgedBExN5yL8iHpkh6KrCEELIEYczEWXoRRjq9To2792D1W6jWCjg1KlTWD52DPlCAXNzc5hbWkI5EzJm+I4iIwcZMiCeJHzXhd1swmo24fk+wiCA43mwXRcsiqCqKgqFAoqFQkwEdB26po1VSy9JQY9QtwiNi9LFjlA9jwik2iMhiKIIruvC9X1Z/aAQgmKhgFwuJyfaZBnlvvMR+X4+kdbrdQDAXK0GVVH6phK2trbwySefoN1qYWFxEWdOn8ax5WW0bRuEEMwntApRYvIPE9GA+DQ6fQ8UXpWhalpMzpLpmcSxjosgDOF5Hjzfh+f7eLi1hTu3bqHVbuPEiRNYXl6WpDBfKGB+YQELS0solkrQuYdDhgxHHRk5yPBYI3BdNOt1tBsNeJ4XTyp8grEdB34QQFNVlEsl1KrV2ORnQlDG5MTXjaS4MA3k4zuENIhogu04MgRvaBpKxWJn8yT+vXs7wj7ZcV3YjgNd01DhJYnd5CAIAnz19ddYv34d8/PzeOWVV1BLrLC3d3fhB0Fc4cAYQhEh6bEtRVGgJ7UamgZNlGYCHbqDXudMEx4I44LxUtMvvvgC19fXsbqyguMnTuxVjXBBaaFQQGVuDnMLCzBNU35lRkwZjiIycpDhsYPv+2ju7MSEwHH2TcSapsH3fUSMQSUEpWKxo1RvXMia/gGPnPBDkEI7pIwSoNM0qV8VAmMMjuPAcl35mlI+39k1sUcZoiAH9WYTURTFpYU9Oi1ubm7i008/RRiGeP7553HmzJl4P9wp0fN97NTrCKMIBV7ZISAqCETFRi+xZs/zxoBrJESKUxrmrl27hs8++wzLXLDo+z4C0dSKpyRUVUWpXEZtfh7VuTmUSiUUCoUsopDhSCEjBxkeC4RhiFajgebuLhzL6pj8FEWBoeswDAOaqqLZbksTokq5DDOX67tdYYcc8JLFMFG+GCX+xsBD4rzdsZIwK5KGRXzyULr+JtokK+J9ia9BYCIl0SOqEIYh2rYtdRS6pqFYLMrISPfrGWJS1eBGRjWRUuBwXRdffPYZbm9uYnV5GS+//DIKhQICbuzk8bQGADiehyAIUCwWUSmXJREYd4Xd3WtCpB4A7PlLcDHiNNbwd+/exYcffohqrYa333oLiqbFxlVBAD8I4gZZUQTf96HqOqpzc5ibn8ccJwq6rk/hKDJkmC0ycpDhOwtKKVzXRWN3F1ajgdD35f90TYNhGDAMQzYKiqII9UYDQRSBRZH05g+CQObDkz+HfMUoQBKTPbC3eu+VQmA9IgOMENAwBBLq/44VfCLdIPfBSYPK3RINw0Aul4PZVUHRQRS4rkDYH1u2LV9TyOfj0kThpijeD8Tuj64Lg9sSi7/f2NjAl19+CUVR8NJLL2F1dVUSgiiK9lwZCYFhGCCEwHVdqJqGWqUy+EMU55+wjk76MxDEqQXhASE1FNxrIWnIJF5HAShimwl0vH4Itnd28P5770HTdbzzzjsoFosA4uhQyEmCzztn+ryNdr5YxPzCAuYWFlCr1ZDL5bKUQ4ZDi4wcZPjOwfO82AWvXofnOPGEC8DQdZimKRv/APEK2nYcNFst7DabCIIAoBRGLrcntiMECtAxyUnbYV69IARqKv+uqCo03hdAlL3JRkiiTp+nGMT3KNE0iYn/9fgZ2JvskyQD2Ct/ZIxB59GQHP8S0REhcqSIJ8QoimRrZcYYNFVFsVjs6K7IEE+IlFKUikXkDANty8Knn36Khw8f4uTJkzh37hwYv6bJngwGL/cUxkyChAHAfK22R2J6pDPSQnZvTAEhrOyFJLHrJkgAOgiaZVn41a9/jTAI8Pb3v4+5ubl92wvDUPaU8FwXQRQhZ5qo1mqo8WhCuVzOUg4ZDh0ycpDhO4EwDOE4DtqtFpxWC4HrglEKVdNk+Z6qKKCUwnYcWLyJj+d5oFEEl0cVNFWNXytC+4n8t1DIa0IYlxDKdYMxhpCLG9NAKOzTTHBUEAvEOgDGmHRMFKFtUfInXi88D1RVjSdr7nsgyAMhJCZVti3D9HnTRCGfByEEfhjKKoVatYpr167h66+/hmmaOH/hAiqVSoegUOeEQEQKgM40xc7uLihjqFUqnU6IE2AUXQFlDBGP0vQFJ37dQsnkOzzPw6/few+NRgNvvPlm3/JM8RnZrgvLsuB5HjRdR7FcRqVWw/z8PObn57OUQ4ZDg4wcZDiyEGkD27ZhWxYC245TB4zFSnFuI2zzjn4Wb+Ijc/+EIOJlc4ZhwDRNVMpl6VUgGxqNCMYV+KO+Z5qPoiQLvg8vCBCIJlCUAoqy5zDISyZ1XYeh69B1PX4djyAoioJSsQjf92E7DlzXxTfffINmo4HjJ07g9JkzUqegaZo0XJJdJPug2WrBDwKU+ggbx8Eo0QNgcNXIMEjSgNgX44OPPsLm5iZefvllnD59emAXTMoYfN60yrFtUACFUgnFchlzc3NYWFhAidtLZ8jwqJCRgwxHDmEYxo1zLAuh6yJwXURhCJ33FSDAXnSARxCkyI+H+Qv5PBRFQcTV5TnDQL5QmFiwJjQGoz5WsopB9CVImYsW+fV45535eXlMCdMgGV1IRBnkvkVeHpACOyF89HwfD+/fx8MHD1AslXDumWdQLZU6tA7qgNB4sgskYywuiXRdmIaBEs/Xy2OXPxLZVVKeCzpbXAudgDjPUQczkcqZCPx6f/HFF7h29SpeeOklPH32rDiofe2ukzqDKIpgtdtoWBZ830e+UECpUkGxVMLKygqq3IEyQ4aDRkYOMhwZBEEgWyIHnge31Ypz/HySdz0PtuPEk1pXy2LTNJHnJXtmLocoirDLw+RmLof8lJrshNzHP6lH6J70901wiCeJg5oEkqI9Rmlsuey68FwXHicOvu8johS266LZbOLm3btgAI7Nz+OJJ55AtVxGPp/v9H0YQTMQBAEsx4GqKLIJUz+Iyg01UaUhyhzF3wSSrbGBhDCxi0BJMWNCzzExGMMXX36Jq1ev4sc//jHm5ufj4+/xuqTldPwnBs910Wg20XYcmPk8qnNzqNZqOHbsGIrFYkYSMhwoMnKQ4dAjCAK0Wq04JcAYnGYTvmWBArGLneeBcNc8ESHI5XLI53LIcyfADsEXY2g0mwjCEKqqxlUJYxwXQ6fqnfImTOPYHU/7MUzqDYQAT4gghehRGD4JYSNJfPc40dqp17Fx/XosmGQMa6urKJRKUFUVOtdz5PP5fS2Y+x6TqBygFE1eFlmtVHpes1GcDgVZIIoCNVEGmiwH7QdRjgpF2YtEjBC96d7W3/785wiCAD/58Y9laooknCR7bjWxvyCKsLuzA9t1UZ2fR6lcRrVaRbVazUhChgNDRg4yHFr4vo92uw3XdQEAVquFnYcPEfi+XDGK0LOh68jz6EAulxsocnNsG5bjgDGGWrU6ktFO38ZFPH898sM0xqpVHEEkKh1E22L+uxApDtquiB5IDwUuvmSMIeAliDu7u/jmm29QLpdx6vRpfPrpp3j+ueegqSoYYo1BxGIXQl3XUSwUUCoWYZqm3P4gbKcQJYoqjjCKJLmRLZp7pASSBlJJKIoi22DL6EPiZ9q1LVkuSfbaT6f9lNqtFn72N3+D48eP45VXXul5LAK97ieRerFdF7v1OvRcDqVqFeVyGYVCITNVynAgmI5MOEOGKUKUInqeByCur29sb8N33Xi1qutSN2ByRb2m66nC2iEPZ4OxfdbBAqLWPTlsD5vohMnRqGC93AhFGoIfh4gsSIMlbq6UFopYTWta/J2vspPkirLYOdHjOoPNzU1cunwZx9fWcPbpp2HZNhRCUC2XYebzsilUGEWyC2Sr3Uaj0YDKbZkLhQKK+XyHJgDYu5aqqoJxkWS/65usGNl37dhei2bZQIlHASgnLWLCF68JB+xHmEFpuh7vL0EM5Ouw95n1c6Eslct46cUX8cknn2B5eRlra2sd/0+SkKQvhjRs4j8XTBP60hKazSba9ToYpQh4JUq73UaxWESxzz2cIcOkyMhBhkMD13XRbrfh+z4opWi1Wmi324hcF5qixOK1fB6VarW3wn0IMWCUom1ZAACdi+jGIQK9MLaoTbwvQRII1wL4CTLQry5faitESJ1/EZ6X75h8OJKiOEopHNeF47rx3wjB+vXr2NjYwDPnzuGZ8+dhW5ZM2RQKBRi5HFzPAxhDoVDA4sICHMeR1QyU0pgoNJtQFEVGFPKJbpAMgKKqQBjudZ8ccJl6/Y9wHwk5OfKUQMQNkcS5JslDx88J8iBKT0PXBVwXIAQaT50IsiBLMlMQhlOnTuHevXv49NNPMTc/HxtL9UAypZT00eAnCF3TMF+roW3bsJtNEEJAKUWhUACltIMkZG2kM0wTGTnI8MgRhiEavPFRFEVoNBpwXRcKpVDCEAYPWVdF+HnMnGvbshBFERQS90voJgXjQkxAg3LBYkKWNfPCiIj/LRIWzPyrV0pAVZR4stI0qNxwqSOPnWL/8cu4O2KCFAjNxsWLF3Hn7l28/PLLOPvUU3GUBbEDo3hvkVd62LYNj0cNyqUSyuWybM5kWRYcThQs20ar3YaiKCjk87JXhaYoCHjUottVspflcy90/F9cX1Xdi0bwSZ4pCvQ+10ekKkQ3RmGdLT4LSRZ4S26Ne1wk7599hIEQfO/VV/HTv/5rfPzRR/jBu+8OORNILwpBMkjCOrtcLELXdViNBmihAF3XpdFVu92Gbdsy7ZBpEjJMAxk5yPDIwBiDZVlotVrwfR+7u7twXReGpkELQyiEoFKroVQsyslpjJ1IgV0QBGAAyqXS1AfQnrnjrrK85DGFfDLyuf9AL+mPxhsRiS/pHZCS1Mi8P9lzdaSMyeoEETUR+/ntb3+L3d1dvP3WW1hbXY3TBkEQH0vy+hMCk0cBLF6CJ5wTRaSgUCjslSzaNhzHiasfbBttbtesqqpsv7wvctMr2pHinPcOsVP8l4wkJNMBjLGOCoiklbYga8I5MgwCeT2SZEH4YnTvM2cYeOP11/HLX/4Sl69cwblz51KfCwOkG6YgCjnDgFarwbIs3L9zJ27uNDeHXD4PSikajQYcx0G1Ws3MlDJMjIwcZHgk8H0fjUYDrVZLkoK8rsMkBBpjqM3PS7/6UdEx0SgKQm4PzIB4xTolRz6BoX78XC8QBIHUC4ia/CQpECRArE6BRMojJZnpjlAkSyZFpEDsU9U0FEwTQRji17/+NTzPw++8+y7m5+c78vkAeub8Dd6/od1uIwxDNNttlEulOKLByzgL+TyK+TyoiFTw9EPI+1RYjoN6owHHdVEsFFAsFPbOPbGvjtK/IemjfloAsZ3ktpMVGkRRAC7wlM6XvOlWGEUxOeDHnSQLDr/WvcjCsaUlPPPMM/jm669xbGkJtbm5zs8zhRhVEAWGOHpULhahuS6sZhPtZhP5QgHHVlagGQZ838fW1haKxaLsDZIhwzjIqhUyHCiEluD+/fuo1+twHAcFXYehKLHnPA+NiteOiu6KAsbLFsNE2eJUkJh4u532GKUdKYIw3C+DE6tVQQjkyrOrhG6Uwb3XKxkA3/NkiB98pS7KD3frdfz617+Grml45513Opz5PN+HbdtQVRVRFOFnP/sZfvfHP0atVpPkRrhMypQNd1QUE3yyB0Ty+FzXRduysLWzgzAMUcjnEfGhqFouo1oud7Rz7nVefAc90w8R/98oEKJPWdY5YBuCLIjPuXsYJZwsiD4bv/zlLxEGAX73d3+3MwqWiGSkSaMk4QcBHE60wFjssLi4CJ1fN1VVZYOnDBlGRRY5yHBgsCwLt27dwu7uLnzPg6GqqHCHvGq5jJwQbaUt7xO56gFhdttxZA6/MmYkgrGEx36P+ndKaew4KMSDfciAputydamqqmwhzMBbDDMGjKI8TxxLr/P3fT8O54tIAe8bIXopbN6/jw8++ADVSgXf//73pVeBmKRECF3XtH02w5LIII5AlMvlOIIQRWi1WigWix19FYTOQmzbNE3pPxGEITRNi82twlCKGUvFImqVSk/xKdk7kK5LwvP1GL16RAoDu/QPsmIksV+NV1CII+tFFoTLJACcP38eH370ET7+5BN873vf2yODiYiI1C30IFO9oGka8vk8PM+D5/uwWi04loVSpYJcoYBiqYTt7W3k83lUKpVMsJhhJGTkIMPM4XkeNjY2sLW1hcj3oQCo5HKo1WqoVSqyzh7gxjcpwsYAN5YZgICvrNiAssWB++kqMRM/A5CDv8db8nZHBxSev9Y5Ieg2YZI6gIQYL7XQMkGKesEPQzi2LSscFEKQ55Ox2Nf6xgY++eQTrK2t4Y3XX++YOETYO+DnpOt6XJ2w/wLJc1EUBZVyGW2uQWhbFgqMweSr1u7UiGixLPZbKZexMDcXd8hsNqXbZbvdRr5QQK1SQZFHlPYdRvcx8b8xHimZBEkRZ3JLoqOlQJIsCM+LZPSokM/j3NNP49uLF1GtVrG8siKbXslrn4wYJX7vRxQUrhchpglN02DZNsIwRKvZBKIIVr0OI59HNDcHz/NQqVRkVC5DhmHIyEGGmeLmzZu4ceMGWBCAUIqiaWJxYQHVajWuc08az7D+ToHdOfQ0sLjwzeBli6mRWBXLfXMEQQCP2wvvvZx0CAd1TetNXLr0A6NoCTo30/s9DLHBk+N5IIC0jTYTpIAB+Prrr3Hp0iWcfeopvPjSSx3nJ+2cE6HyfhoNAuzZEvNzKRWLsBUlntxtGzSKOiakDpKVKNuLKIWGWBNSyOfh+X6sRXAc+J6Hzfv3oes65mo1lAYYAHXrTeKTYnvujAMwShpLQSKqgD2yA3TeD/HuY7JgmiZ2d3Zw5coVLC4uwuWNw3RNg8G7ZPYiioKY9Ho2FEWRhlTlUglty5L6j0qphMjzcPfGDeSLRXiuixJv7pR5I2QYhowcZJgJfN/HpUuXsLu9DRIEyOdyWDl2DNVaLR6YeqQOOhrn8BA76Qr1jrJ/kU4YulrqRToS+4uiCD63aU4es8IV5AZv9tTLi6DvRJ5yImKMyajKIIRhCMuyZI2/mct1+AoA8eT38aef4uaNG3jxxRdx9uzZfefdHTUYWjqaCIWL78K9z7ZtuPyaFbtK7MTPqqoiEN0iE8gZBpaXlhAEARqtFtqWBUopHmxtYVtVUatUUC2XB5IEkQ5IkhCR2uhugDSOhTXpInki1dK9lSRZePnll/H/+6u/wu7ODpZXV+PUAy9jtQmR91O3AFQYI3Vcb/6zeJ7A9R6tdhs0iqRAtFgowPc83N7YQHVuDkEQYHFxcerC3AzfLWR3R4apY2trC1evXIFv21ABLC0vY21lpSNHvs/2lpOFpGnPuCtrALEqH+hYNYv9DNIPJF8ncrnd+fYcX+Uly8XE5NLLdKgXKAaLz8S2hhEDhvhcHccBQTzZFgoFGF2lbJQxfPjRR7i3uYk333gDx48fH7jdMJFSGIRkRCIJ0zShEALLtmWUpdRD86GK1tl9yJKu61icn8dctYpms4kWFz5u7+5it15HlZOEXhNdT90BJ4Lyf4QAU+jM2K2tEPvpJhzlUgknjh/H9evXcfappxABe8STNw9zPS9uf80jXh33U9fP4jeFu00KQai4Tm3LQol7JGiahla9Drvdhus4WF1by8SKGfoiIwcZpoYwDLGxsYF79+6BuS5MXceJJ57YqxDgA2d3xIBy4xclObFOkCsOErXpUszG8/tI1tT3ELMJHUHQpSHQNQ25XA56MvSbgMifp119Djq7tCmUKIpknpnwVadoRd1xXgA+//xz3L1zB29///tYXVnps+O91XWYjBwMQb+QvcEFhy3uemkRsk83oKhqfJ7CqRC9r42qqpjjXQpbrRZa7TaCIMBus4ndeh3lchlzlUpn+qgrPdR9rmI/jJAOp8RJy/+6IyTd1Q/PnDuHn/3N3+D2nTs4fuIE8jz1E4ZhnLISJa9hCNtxpDah12chxYyIhaGiKqdULMoSU8u2ZeSmUCjAcV3c2diA1W7jydOnOypUMmQQyMhBhqmgXq/jxo0baOzsQKEUtUoFaysrexUIwF7uNzlg8wF8mvXYDnf1yxlGbNGbNAPq8fogCOBzUpCEqqrIGUaHkG8QVNHAZxhBSEEghu3NdV1YjgPRzrhQKMSrzH0bIrh08SKuX7uG7736KlY4MZCtjJFQ5fNJPuRNnEQkQnxmoh1yr9V4P2i6jkKhgDZPMQgdhFhVi5x5lLwHBlwfhRBUKxWUy2XYto1Gswk/CGIzrWYTxWIRc8JeW9xrA45P6AH29TeYYoV3R/UDIajVaji2vIzLly/HERxOinUejaKUxt1GfR80iuIIludBU9VYm2AY+yNK/LgV3iJc0zQUi0W0LUsKc0W6p5DPw3Yc7G5twW63cfLMGRw7dmyqz2CGo4+MHGSYCGEY4u7du7h/7x7cVguGpmFpaQlLCwvxxJxAh4882XPsm+aQFEYRfO6EmM/n+6YmIkrh87RBMqSskLjds5FUkXedw6BBVFEU0CFNkbrJQ7+tdUzcieO2bHuvkkDT4kGf7JXbJXHjxg189dVXePbZZ3Hq1Cm53WRuvGPCT9T693Kl7JebF9vsdW0Mw0CBUtiOA9u2QQiRK3yRpxedFpPaBSnySxAZAWGBXSoW4woH3tLbcRxYlgXTNFGr1aRTYz8wSjv+vy+qNEWSILdPCC488wz+7he/wIP793FsebnjHlUUJe4wapp7AlhuwBRyt0lD12HkctLRUUDlpaEAYGgaioUCLMuC5/uxHiSfB+ERHNfz4Ng2rl68iFajgTNnz2ZCxQwSGTnIMDaazSZu376N1u4uAtdFuVjE0sICKuXyPrW+HIQJgfiPKFuclBwkRWeivbPOOzd2v87nK7Lu0sNk6LbXBCcm6FQRBG4a1OdgQSndG4R7iNiSYfrkBO7xCgCxGi4WCgNzxvfv3cPHH3+MM6dP48L5831f150WkCmFEerie+b3EzBNM86p874LYqWcnIQ7Ugpszzypl8gvqdnI5/PImya8IECz0YDtugjCEPfu34eq66hVKj1LWUUDpn7nE/+Q+BymSBQWFxexsLCAS5cvY3llZe9cu5CMJojoVhRFMrIgolvCrRI8vSUIryBhbcuC53lQCJGpNjOXg6oosGwbd2/dQqvRwDPPPZeVO2YAkJGDDGOAUoo7d+5gZ3sbTrMJFkVYmp9HrVaLc8o9cvnS6Ce5nQmJQYftLeLyO8/3wRiTXfCE653LeyskMUxHICH0CilBsJdiYMnJj+25CnY7/HXvr+M8RbSAr/40XR/q27C7u4sPPvgAa6urePnllwdrOLrSLaPoDTo3M/jTFKt40ZK7XKnI1sji+nTk68HTH9gf5k/uSfzP0HUsLi7GRkrNJtpcj3H/4UNs7+ygVq3KCoeIMURcq5Hq3OIT3Kt0SPWuAdsjBM888wzef+89bG9vY2FhoSNK1H1PKIoCM5fr1CZwsaztOLBdF4auI2cY0DUNgvIQxOk1JiI3PBUlSKWu67IEstls4rOPPsLZZ57BsX66lAyPDTJykGEktNtt3Lp1C75tw7dt5DQNtcVFlEul3m2UEeeyuwfT7trwUSBFWDzkLODyvgE6X/3bti3JgoAoPxTufD233x0eH2PFSAiBoqqxtS3/XZgeRSOcc+D7sGxbru7zphnn7Adso91u471f/xrVWg2vv/76ULOo5JaSq+mxHPWG5PhFq+EgDGG12yjzyVq0T+7+TMYJ8+uahvn5eVSrVTRaLbRaLVnhsLO7i3K5vEeuEp91dwqq11mI6NE0SMLqygoq1SouXbqE73//+x37lGSkh5GTKIvM5/MIEpEwnxMGRVXj5mUJ8y3TNCEbYTkOwAWsQPw5l0slKW69/O23sFotnHjySWij+INk+E4hIwcZUoFSinv37uHhgwegQQASBLL1brFQ2EcMxGqv3wA6iSq81/toFMH1fYS8SqHRbHa8XoReB62GB6YOxsxBixCv2GIqW2i+H8u24XueDBUnmxL1g+e6+NWvfoVcLoe333576Ou7PweRDhFdCkeFWOn3AyEERV6LH3GrZHFNB12bjtLDlNdQVVXM12rxyrjdRrPdhud52NndRbPVwvzcHAr5vCSP3akDuZLvKn0lSJCECVINhBA8c+4cPvzoIzSbTVQqlc4X8LLbfvsQ+phcLoeQCxd9LmJ0ogjUtpHj0QaF99NgjMmeGYpI7QCym2ar3QalFJt378K1baydPInq3NzY55jh6CJTn2QYCtu2ceXKFTzc3AQ8DwVdR7VaRSGfjweffD5+IdvztY9/7b+ySjtJdojsuiIFSVi2Dcuy4HDNAbAXMq1VqyikmFh7kpi9AxkrgqAA0Hgtf1qjnTAMYxU+TyOYpolKn1r+jvcFAX793nuglOKdd94Zq4ZdRDrGNchJo/RXFAWlUkkSJ+FJMez6JiflUaAqCkrlMo4tLmJ+bg6GpoFSivsPH+L+w4c9G2MBCb0H90GgXC8S8S8qoiRCNJl4T1ocP34cxVIJFy9d6v2CxDM16Kw1Th5r1SqKhQJ0HjXwPC8Wa3penG7L5+M0GiDdFMUzJTwSCCHyHrxx7Rpura/37BeS4buNjBxk6AtKKe7fv48rly/DbbWgRBEWFxZkLb3Oc99yACN7PgXJ1XI3+tWyd7wmWdUwgBSEYYhms4mt7W34vi8rDaqVCsql0nA9QddxdWPU2EZS+Z98r0LI8JU4Y3BsG61mU4bYy6WSVJgPAmUMv/nwQ1iWhR/84AcopGgy1WsSj8YQI3YjbdlnqVSK8/+Uxg2ihlR5jLoPIP4sQkrjckW+z9WVlfjeUBR4rovbm5vYbTRGNkISLa1pgjyAELCkpmQIFEXB008/jbu3b8OyrKGvH0YShJ6gwlMnohTV4RUdQRDEESj+XIgIjoCqqnGrdELg+z5cz0N9ZweXv/kGrUYj5Vll+C4gIwcZeoJSivX1dWzeuQPmeSgYBo6vrclVlDBakbl0/iWdDgdse9DAuU9P0GcSiMIQ7XYbjUYjttZlDLlcDosLC3JQ3IfEoN1rYpxIHAlI8eGg7SiJJlNJRJzkuK4r88GVSmWoQ2G8c4ZPP/4YWw8f4u2330a1Wk11zL3cHEXkoFcZY1qIfPwwiHtI4ytVm/tTpEV3V8PuY6BcdNgdkVA1DQvz81heXoaZy0EjBI1GA3fv3euIPI0KoaMRlTmUMVB+HL3KTAVOPfkkcqaJK1eupN5XRzShz7XOGUZMLrm/AeXC1la7HVcq8M6QTtd11zQNBR4NdF03tiIPAqxfuYI7N29mUYTHBBk5yLAPYRji2rVraO/uQglDHFtYwOryMlxeRkUIQaVcloPLPnviYRPDkNxyGlJQbzTgeV48CVCKYqGAhfn53t4E2D9hTdPwRRKaIaRIis0IgUr2rJFd10Wz2UTEowWlUgnFYjFVTwUA+Orrr3Hz5k289vrrWFpaSnfMPSYr6TWACSMHwODqiAQ0TUOxVAIB4rr7UQkCeBVMYn+U+yZEUbSnU+iBXC6HlZUVzPFUQ0Qp7j14gAdbW31TDSND6CkQX9+IUlB0Rpg0VcXZs2dx48YNWYo7CqQmYt8/iNTbVMplKWQVtsqMMVDePbKjkRhiYiEEixZve04Iwc7Dh7h26RK8CUhUhqOBjBxk6EAYhli/dg1uowGFUqytrKBSqcDm3fEIgEql0tMPYJ/7YR8kJ+l9eoKUpACIa7jzpomcaULnpjAssUoTX6Tra1pIpg/SbLfjyvActcNNbcDFYZVKZV9fhEG4dvUqLl++jBdfegknhvRL6EAP4aAI64t+B5NglHcbhhFPXIzBdd19TpWpwBgiShEKUpC8D4fck+VyOa4cKBahKwpcx8GdzU00eHpnGiCIo0aEVyCIVITQLpw+cwZEUXDt2rXRNy5ScOh/3QmvdKmUy9L7gFKKgHsmWLa971wLhQJ0XQdjDO3E/z3XxbWLF9FutUY/1gxHBhk5yCAhiIHXbAKUYnVlBaZpIgrDuLGPoqBcLvecvNKK7US4VWCQngCIqxDa7TYazaacNHTDQLVaRblclhOaWOV0E4xpkoHkOYylUU+SIsbingNBAIUQlEslVHhZX1oF/J07d/D555/j3LlzOHv27EiH0uu6jOtv0Bcpz4Moyl5bbV6C6nd5UvTfBScFlMr97fNESKOB0DQsLCzg2LFjcZkrIdit17F5//5Yq/lB6BVt01QVJ44fx82bN1N37Oy7fbEPxEQvCVGVIASuhq4jFCm6ZnPftSsWCtB4a/XkdYiiCOuXL2P74cOJjjXD4UVGDjIA4KmEK1fg8wFCEANRGy3KngYq4IdMBowxMBFOT0EKrGT6gLFYaFityoGNUiobLOmcHPS0wp0iWEKZPo5YEYhXbM1WC0EYgiBeuYr+DYqixLbTQ67Pw4cP8dFHH+Hkk0/iheefH+s4ujFppcI+pIw+iPSJkQxl86ZBvcAYA0tGCSjda+2NRAvj5KGkPGTTNLF87BjmarU41RCG2Lx/Hw+3t6eXahDH1EUSVldXZb8IEVkYu1RSEKU+n4HwNhAtnRmAVruNnd3dzhQDIXv6A9/fpze4c+MG7t66Nd4xZjjUyHwOMiAMQ1y/cgVhqwUKSGIAkZPkg0V3Rz0BodoeJkKUArIhpMBxnLjnAVd/G7qOPC/PSiLgPRSSNflixTRtyPTEBHXtjFK5SqOMyWqEbp1EslwvmZsWplHNZhPvv/8+lpaW8Oqrr6aehAceG8/TA1MkB0jnZyErXBiTLop+EMQuilzbIqI1lBODodqO7gjMCP4IiqKgUqmgWChgt16Hbdvya65WQ0V0GZ0ShJD32NISdE3D5uam9Dzojsj11Rf0Oxd03kPd0HUdc7UaFELQsqw4QkgIdN9H3jSl4ZKu6wiCALbrolwq7bmTEoKtBw/guS5Onj49kZA1w+FCFjl4zOH7Pq5fuoSw1QIjBE+srsqueYQQqSA3crm+k8YgPwMhCJPpgz4DNOUiqd1GA47ngTIGXddRLZdj1X6PfftBAIiowZir+WEYO4XQA57vo9VqxdUeioJKD2LQDcIjLQqPKvi+j1/+6lcol0p46803R26U008XIlapInoxLaQJ6Xd3YyzyapOIUjR4hCWKorih1RBiILeJ3tUYo0DVNCwuLuLYsWMwee+C7Xodd+/dm0mqQdU0HDt2DJubm31fJ/QK+3QVw7aPwXqEarUal3caBgLeMrrVbsOyLERRJO3IRSvpbpvrdrOJq5cujacXyXAokZGDxxiu6+LG5csILQuUEKytrMRtf/mgGoQhQp77FaHFbvQzrxEphO7BmXQRBBpFsDkpkPbHuo5qpYLqgFI+xhgC30fEGHK6PtGKvh8kscHkpMN1XVjtNhi4OVO5vK9r5TAQAJ988gkIY/j+O+9A07SOSow0k0UyKpGECJmLCpRpIU1Zo2jbTHmqgHKzHkIIojBMVf/fC8nqkEnOyDRNLC8vo1apQFdVhEGAzfv3sbW9HWsdpognnngCO7u7Q8mHLBtOiBv7dstMvg+972WRPhC9GUS1ih8EsbOk70utkSj37G7Y5bkurnLr5QxHHxk5eEzhui5uXb4M37b3iEEu1xG2dGwbAJAzzd4rXJ522PdnDAl/8oHNsm3s8i56ogd9pVweSAri3cbNlChjUBVlqmFwcfxsSqSAIXZvbFsWGC8rE+Y/o+Lq1avY3NzEa6+9Fqd9SKeVb8fxA4Co3EgI9fqldMbpxJgG3WWN4niSan3RIlqUIDKecilyHw2fty0ed//9CNEoUBQF1WoVT6ysxA6EqgrLcXDnzh00pzgZrq6uQlNV3Lt3b+T3Jq9r8h7oC9Jp/2wYBnRdl5qXSrkcR+xY3CzLCwL4QYAgDBEEQQfRF9HDKIpw7fJl7GxtjXz8GQ4XMnLwGEIQA891wQjB6vKyVGiLIdT3PGmtWujTUCnZNhfoSiH0AiGgnBTs7O7CcZwOUlCrVmWZVV/wwUiIpoQV7DSQTCFMIxLBEDdBcj0P4KthMeGNivruLr746is8ffZs3OK3B5INhMSknAzZdxOGZMQhmND8KNlaWWoD+IQvSQCv8xfle+I1yeNMTlaiuZBCCCzLkoLJcSDu7Ul6IQDx9VlaWsLSsWPI6XpHqmFcApOEbhhYXFzEXZ5aGJfUCDOmiBOFbgj9THfqpZDPg4CnD6IIpVJJmooRvl3LstBstfb5hkjnU8Zwe2MD9Z2dsY49w+FARg4eM4hUgue6IIqCJ9bWZAg3CZuHDvOm2TP8zRgDEiFVKTjsA9HwpVGvj0UK5MTNBzOfixH1KXWNm2YKAYgnx2arFZMYxlAslWTedlSEQYAPP/wQtUoFz41YmQDsCUH3nVdi1Rfx1buqKHLiFqHqfTbBif4C4ksQATEpCRICvqIcNil36w4EclzrQgiJu1OOfPad+xilVHQQ8qaJleVl1MplmWq4e+8etnd2Jk41rK6uYuvhQykQTbqPjowEOevl2SAmcxEFUBQFJh8PbO5tIHqUFHiDNRH121f6KCpG+PHeWl/PUgxHGBk5eIwgiEEgiMHqak/PAkqpLFnq1YZZ2MSKnwdGCxBPlG3LilvnclJQHoEUCIg9iBI2ACMZBvXcPjqNkqaBMIrQaDbj0OsAb4i0+Ozzz2E7Dt4YQ4AoMCj3LyYNQohcIe4LxXdrR7q+hmHoCrhH5EC8r1gsQlFVWckyLsQx9Cp1HAeKoqBaq2F1eTlONSgK2paFzc3NiQSLq6uroJTiwYMH+/Y3CkQEJ/l7R9OojhczSSANXd9nrSycFquVCkqlEgDAcZy4N0OCxHRukmHj2rXMTfGIIiMHjwlc18X6lSsIXBeKouD42poUH3ZDiBDVRD/4JLpX8YPgBQEa9boMuebzeczVanumRX0gc+UiVJ7Yj0wpaNrE/RCA6VY4BGGIZquFKIqgqmqct9X1sVe8N2/cwI0bN/C9V16JG+JMgH6fleynMMUqhV4YtPIVXge91tzCuIcQEnv9pzRI6kaHwn6K56rrOpaWlrC4uAhD08AYw+aDB2NrEYrFIqrVKjbv3t33PxlFSLGdQddbmEeJqA+w9xwoqhq3skYsSAwS15sQIlu1C41IiwsWO7bPXxuFITauXp26R0SG2SMjB48BbNvG+tWriBwHqqpibW1toOAvGOCUJ1Tl+yaaroGIstgBUEQLVFVFtVJBkeeQh0E2c+p1fL4vVf/jYhbEwPN92VFR1zRUeY3+uKvUdruNTz/9FE8++SROnDw52cENOAYRJZpljfowUaD8T5/j1HUdJjeKsm0b0Rih+33K/Sl7YhQKBawsLyOfz0NTFGzv7uLB1tZYFsxra2vYvHev73vFcQ+6s9Lul3KiICNIjEHXNOR5LwabpwEFNFWFqqrIc6EyYwy2bcdpny6iIQjdjatXp2ZFneFgkJGD7zhs28b6tWuIbBuqpuH4E08MDXELctDtLSCc6eTknhzIkyv7HtGCWpdXQa+JYpBZi0DEG8UwSoeLF3sgSQqmOTE4rhubGyFWfZfL5b3V6RjkgEYRPvjgA+Tzebz80ksTHduwXLWYaIe2lJ4QA42L+qQVkjDzeeh8ZT6O/qBvnf+I2xkEVdOwvLQU3++KAsdxcPfevQ7XwTRYW1tDEIbY3t7u+X9BnpX4l33/T1NC2us9QjjKAOS5SFm0fBYQpmOEEJimGWtpSNziOZlmkK8nBLZl4c6NGyMdT4ZHi4wcfIcRhiE2rl9H5LoxMVhbGzoBJPUGYjKX6vbuwaZrUKKMocWVzN3Rgn1+B9gbvKQxDxvc1RCADHFqup66a6HA9J0QeEWCZcHmZZ9500S5VOosLRxDcf7VV1+h2Wzi9TfemLnrnGy4NGNy0F061/0/AAOJlNAfEEIQBcF0jIiEWHOK3g4AUK3VsHTsGAxNA40i3L1/H+12O/X7a7UaCqY50BAJQIfQNHmfTdKfgRASC08Zk5ojz/c7Vv6i5DUMQ5imiXKxCEVR+qcZGMPu9jbu90iVZDicyMjBdxi3b94EdV1ohKQiBsBevTvhHv9Jm9RBkNEC7pCWN8190YIkOnKnIwzQPk8pjCrwEwPnNKcAkToRA2GhUEChj8X0KLh37x6uXr2KF154AbVabeLtDQJNhJNnrTkgQF9Cl7RQHgRFVaX+wHEcGeWayvGNWxHQB6KiIW+aUBUFD3d2sLW9nTq8vrq2FpODFMckogjyOk4phK/zck3GWFySy59ZkXJMWm6XSyUZ2dmXZuDP94PNTexmHghHAhk5+I5i6+FDWPU6GKVYXl5OvSoMu6IGyhABVN9oAR/A+0EIlkiKaIHcV7LRUkpyIKsRRthPGkSieRIvVSyXSj0rO0aF4zj47YcfYmV1FU+dOTOFIx0MkVJQFGWqtsl9MYQcpIGRy8HI5aAoCizLGkooRoGSUuyXFsIXoVIqyWqGew8ewE9BakQjprGEjVOMhORyOYAQeJ4Xl7xSCpW7c4YJG2dFUVBKPAf90gx3bt5Es9GY2vFlmA0ycvAdhG3b2LpzBzQMUavVRqqvF2F7XddlfTzQO385arRAQGxJIWQk1bhotKQqSionv1mIDoGYQDWbTYRRBMKb9EzDb4FRio8++ghEVafaUGkQ6AFVKgyDONO0E32hUIDKV7R2SntlUdM/+EU8jz9NwqEomJubk9UMYRhic3NTpqL6YWlxEbqu4+4IoXjRQGsarpACuqZJ0iTGBxkFYmzf5J83TekC2ivNwBjDjevX0ajXp3J8GWaDjBx8xxCGIe5tbCAKQ5i5HBbm5lK9T9REC0KQDP92N+vpGS0ol4dHC3gJZFIMOMoAJkrYRhEizoQYtFqIKIWmKKhWKsPtm1NONJcuX8bDBw/wxuuvjyW23L/b4U2jwoPSG3B02ynLv6fQHHS/vsC1HUEQxCHvdG9M9ZppaxCAmNAsLy8jx0uI729tYXt3t28KQFFVLC8vD9cdJJDcliQIE56L8DggwL5JXrpcdn1uOk8zaIk0g51IM7AowsaVK2js7k50bBlmh4wcfIdAKcXDW7cQcKHWsaWloe9JerAnQ8u06zUCfaMFQ8L8SQfCJAjSm9JEXEWtDem7MLOIAV8FUV7qVSmXU4Xi00x329vb+Oabb3D+wgUspvjc0mLYNYgmtE0eBz2PKUW1Qjc0VUWeE1LbcVLZK6e+J2ZEEHRdx/KxYygXi9AVBa1WC/cePOjrA7C0uIhGo5FKQyAn6gR6GlqNAUFWI96VMbl9AIh4OWRy74qioFQsdogaRZqB8Kjh9cuXUc8IwqFERg6+I6CUovXgAdqNBrwwxOLCwuDmRYmfpcc6EiVlCQdExpXLHdECRUkVLUjua1Ap2bD0gmi2xHi74777mXLtukBIaezZwD0MyqVS6pTIsOPxfR8ffvghFubnceH8+ckPdgRIQdkBRQ6A3uH9NKWMvWDmctBzOSgALMsaSsRGnSQJpl/loigKFhYWMD8/D03TpPWy06P6olqrgQFoDdEdMNa7CRowHYKgKEo8niiKjB50iA3566Io6oxeECLTDCSRZvB9Xz731y9fxm7Wh+HQISMH3wFQSuE3GtjZ2oIXhiiXSihzi9NuJAc60UmNKMrewNE1SDPG4mhBo9EZLahWh0cLeqQR+mHYwCVWhYqi9CQHs6hGEIgSxEAbkRgAQyY8xvDJJ58gCEO89vrrU3PuS9PCOemOdyBixAS6z1OSgzG2VcznY3tlSmENyeOPDJFim6IGQaBUKmH52DG5Kr/34AF2u4R61WoVBEBjiIAvjVZD6ATGJQnC1TTw/X06g+T2he4heX/pmoZKIs1g8TQDEN+r61euYKePp0OGR4OMHBxxUEoRttvYevAAvutCVRQsLSzse50cOsQg0qdEMbmCo3xSFDn2kaMFI6zih6UXBrn4zaIaQUCUKwo75FGJgehU2A/X19dx5/ZtvPq9702lDFIixSQgryk3tHmUkLX6Y0zCRFFQ4Pek7/sDuyOOe57TtFtOImcYWEn0Zqg3m3Gaga++NU1DqVhEfYB4TzS8GgXjXAdN0+IIUyJ60HNb4t5jrKNUtleawbIs6XGycfUqth8+HPm4MswGGTk4wqCUImy10OTtjwPGsHzs2L5VoJg8AciyxH7eBUKI6AcB6o2GFHqZKaMFYn/A6Kt4gliE1Ysg9Ap/yzLFEfeTFpQxtFothGEIhTdQmuYKu9Fo4IvPP8eZp57C2tra1LYLpJtkRRnjQaYUBLqjSR2tpccgCLquw+R2v5ZljWWvPAyzSDEA8aS5tLiIWq0GnZcMJps31ebm+pIDOiCd0A8daYYRr7WIcnie15FW6N6++LtwaowSJY9500SpWJRpBsu249JOXsWw3dVwKsOjQUYOjigEMfAdB/XdXfhhiLlaDWYut++1HQpxkUoYsHJIdlsT0YJSmmjBCGmEfpAEoQthGMZljPx/sxIdCjAArXZbEoNKuTzVcr8oivDhBx+gVC7jxRdfnNp2gT2B6TCISaXX9ZbbEqs//tlO0ySoA8l7a8x9mKYZN+Mik7d37gmeYpjVNahUKlheXt7XvKlarcZpha79UkpHJgZJyGjdKB4T3JmUcpvlYWNC0iNFRBGET4lIMwCA57oxGWIMN9bX8fD+/THPKsO0cHAS5QxTgyAGLAyxtb2NMIqQy+Uw1+Wml1xVS6fDARNcFEVoWxY834eqqtANIxUpEPualhhQDFoiHMkYi81WKI0bvSReNwswxE2PRHfKcqk09VK/S5cuoW1Z+Mnv/u5Y0QgxyIrvghCICZwJ5XgyrZGc4BPpEkZp7DyZtLNOfAdjaDWbAGLCBEBOKB0RqMTnnyyjk+S06//gk4w4/5CvHoMggKZpnVqYFCCEoFgooNluIwoCeJ7XkyxPCoWQvbLfKSOXy2FleRlbu7twHScudQTghyFsx5Gpp2S4flKIzyIN6SGEwDCMuFuj7w/trirug+S2KaXysy0Vi3BdF67nwfE8UMZQyOdxa30dYAxLKyuTnVyGsZGRgyMGQQwQRdjZ3Y1zf4RgmZe/JSfOfcRgwGAWhSEaXBFNCEEul5Nd2YZhFpN1kiCICZAQAlVRZkYKgPhcrHZbeiqUy+XhPgZDtteNdruNy5cu4dzTT6Ncqci/d0/4yXOX3/nPezvge+ATb/fqXlw3kVoSKSUhNBXHGPHITOfBsz2BKhJRhOR+E/tKht3lvYf990XyfzShFXEcJ349b+wD/rO4FxQ+oRBFgcJX8eJnMdkovFugbdtwXRe6YUCd9iTO992zO+kUIJo3Nep1NJpNhPz+29rawsmTJ6dKDIDE56MoqbQLOcPAbr0uSxLT7YR09lPh5JUoCkze3bFlWbJBVSGfx62NDVDGsLy6OvI5ZZgcGTk4QqBRhLDdBqIItm2j3W4jiCKsLC115Gw7mv6gv75AwA8CtFotMMagaRrmajUEYYjA96Hl833fx/jkMavJWqifvYQYcdbCOcuy4AVBbIlcLk/UFhqIPzPRDpdSCkYpPv74Y2i5HNaOH0ez2eyc8BMTsgRjcTVGj/I/RVVjnYgYfJOr864KjuRKPqIUQRhCAVApl+X/5Xu6ogFiUC+Xy6hVKh3RBXFUyUiDjFqI1yGR7kj8P1mbr6pqrLrn5EVEOAi45mTYvSYIAyHwuKI+jCKUeFMg6chJKTCFFJEgr7O6J6u1GgzTxPbWFnKGgdt372JuYQH5GURDAK5L4vfZoBiCLF3kDpWptp14b5IQCpJgGAaKjMVjmoiS5PNxJ0fGsDxlTU6G4cjIwRFBkhiEYYjtnR0EYRhXDxSLA8VBgwYvz3XR4vazGjf28XwfQasF1/eR70MOZukpkAQhJBaXMTZzFz/LcWS5ZqlUSt+/gQuuKKWyhIvyiUl4RAg8uH8fDx48wIsvvRS/dm8j8eQmVsDiZ/67KlbNidf0bHudcrD2fR+6pkHTtFTnmSQNZJrRG04QBAGglEpnPUmaEhETcT2TWgjw74SQ+HoSAlVV4XgeAt5NUOe9AADIVIYoi1VUVX4fNcUz7V4M3cibJlZXVlAulWC323jw4AHm5+b6lipPCpFiEASy1z0WhCE0XUfI73MRnUoLpYsgAHGpsqHryJsmHNftiCDcuXkTlDGsPvHEROeWYTRk5OAIIEkMGGPY3t6Wedn5+fm+E8KwB9aybdmnPZfLxQpiQqSoS6y8utXss875d++LRVFswjJDFz/HdeHya1EsFnvaF3dP/hH/6g7xJgWBYuBUCEEYRbhy5QqWV1Zw/Pjx1BP+LCB8Ix5FpUIHBMFMpjD4tVN4ZCQNBGEQ5IFSCoUQuK6LMAxh6DoIJxkQkRxCECYjMjyy0kEYeIpD7SfcG0PxPyoURcH83Bw2bt6EqijYqdfBGJMRn1lBVZSe/gli7MkxBigKfN+PmzONgG67bIL4M9REWshxOgjC5q1bAGNYPX58onPKkB4ZOTjkSBIDAGi2WnA9DxFjWD12LH6AE5NTGn0BYywWHiZMjYrFYsf7dU2DHwTwE6mFWacR9h0n/x5y22TRDGraanHXdaUhSz6fh6qq8HlYOhkF6DUJCCJACIHGV56qqkIVq9DE5/DFF18gDEN875VXRmqGNQukqVQ4aExyX4nUSjJdYBgGms0mIkphGIasrw+jCFEY7qV7EqkfUIqIUkRhiKBr4heRhX7RhllUMTB+PHPz87h85QpyuRw838cut1SuVatT32cS3c6VjAtGAaBYKMAPAnjjkAPsRR+TBAH8uuYZg9sVQdi8fRuUMTxx4sQUzizDMGTk4BCDhmFMDPjkH4Zh3NcgDLG0sIBcLidzs8P8C+Q2eath4Y+eNCUB9iZkI5eTD34hnz+wNEL3cdBEGFma9bDezV5G3X7Ic5vtVgtRFMnOiiKaIo8jkbLpnhwEEeh3zcWxN+p1XL16Fc8999x0zY7GhPABeNTdGIH9/gHTmmIVQpDP52WEzNB1qdEgmrZv8GNIaES6tCKUUiAMB0YbiLg3EvfFuJBNjfjnVK3VpKaiWi6jwc3JGKWYS9lcbRzIu5oLMANRUqwoKOTzCIJAtlIfVZ/TsW2eZlAIQcQYNMOAwRhcz5NWy/l8Hvfv3AFjDMdPnpzWKWbog4wcHFJ0EwMAsXI5imDmcqgmVO5J4dmwioRmovFJuVTqCJ+LED4IicOwIrUQhrEYcOpn2RvJyUG4+GmJCVgQIJawZx2GkK8GQ/4VRRF83487xYF79Ou6JFq9ogDjDPaCvH362WcoFYs4e/bsyNsYZV9pXydbNR+GyEGXcHKayBkGfN+HHwSwXRclHiHreRjA3qTeNdEJs6FB0QYAkL6BjEEhBJqmQeXajrROlEmthUCpWISuqqjX63j66acBQtBoNtGyLFAgdffVcUEQEwKLr+RFFM8wDHj8+k4i3u1VHmrwaITreXD5fvP5PB7cvQtQiuOnTo29vwzDkZGDQwhhiZwkBmEYwmq3ETKGYwk/g35CxG4EQYBmuw3GxViVHiV6Im0AxA+roWnw+KBamZEAqhvd05tsKdxDb0C43XJ3FEFEBZJflNIOJXYYhnAcB6qmIW+a0stgFlbCN2/cwNb2Nn7n3Xdn1sMgGUFK9VokTHAOC0QIe8qbzefzcfWNSJPp+shRJ4UQKGmiDYxJ8hkxBhoEQBDIe0/lFsTye9LxMyG07AYhBJVqFU3eY6FaqYAQgnqjAcu2QSnFwtzcTD/PMAwRhSEIYjMkICYJnu/37So5CqRhUmIcMnI5gGtHOgjCvXtQdT0TKc4QGTk4hIgsq4MYMADNRgMRpTBzub2wdEpi4HmeNK/RVBXlcnnoipExhnyhAL/ZROD78Dxv5LziKEgSkyRCLsLs11KYEAIaRXLwFwOz3J4gDjz0KwR4ThShXC7D0HWUZkh8fM/DF19+iSdPnsTSFFsx78MIKZ9H0aY5DeTxTzl3r6kq8rkcHM+D4zgoT/G8e0UbhCeEuBeFxoEyFmsdogjwPJkm0FQVJBGd6vc5Vms1PNzakr9XymUohGCnXofjutja2cHi/PxMCAJjDDZPtxmGIRsoafx4RcXOJJEocd5KlxDSMAyAUriJvhl5rkEol8soJaKoGaaHwzU6ZEDkOGAJcxqAOxfaNgJKsSiiBinFgbbjSLGdYRhx46A+ZEK2aebb1lQVhXwetm3Dchzouj6zgaenEhzcNjlRxigG3ZCnO8IwlKkQUIqIn4eiKHGjGPHFIwJhGMbtb3nqZJbEAAC++uorUMbw/PPPz3Q/o0yoIgSuTDlCMgkIIbKz5iy0/6ZpwgsCRFEE13VnSnRFOaC498SeqEht8Xs3ohQBpdKMSry3O7ognrlatYr1a9dkEzQAshXy9s4OXNfFw+1tLC0sTP05dT0vTkcqCgpcoyTGEVVV5bM4aZoq6YeQTJMZpgkQAsdxpPFb3jSxfvUqLrz44kRGZRl6I7uihwg0CBBxdi6d5QiJFddRBNMwUCwUOohBv4GUMQbLsjoaJ43TTdE0Tfg8bGjZ9tTrq6Viudf/KEUYBHHVhOfBdRxpsStTBGzPOVHjKxqVi866SYfoJR9ReiDEYGdnB9c3NvDKyy93iD4fNQ5jpQKQaPQyA9U/IQSFfB7tdhuu68r7ZFYQz25S0KooChTDgI69dESS6EacCIuJFvzZVXjEK5/PgxGCZr2Oufl5uS/xXO9sb8PzfTzY2sKxxcWpEYQoiuQ4UjDNzu3yyiZxDtMgXclSaXknMCZTGU7CjwQANq5exdnz5yfeb4ZOZOTgkIBSilD0Nxd/5CvddrsdRw2E6GhIxIBSila7vVdyVCwOLZ1LOt0lt00QDz6NVituhxsEyE3oGij32ftAEAqxoON0rPLl8SVWZZqmQVfVngRDhDtFOZhoPa1r2syJAQB8+umnmKvVcPr06ZnvaxQ8ym6MAzFj/YOh6zAMI/bxd5yZ3wMEexOcdJEEOoS04h4Gn1SFd0Z3uaVPKXTDAAGwef8+jFwOmq5D1zQovHJAWVzEFvdAuf/wIZYWFiZeUTPGYNk2wOJmSd3+HwSx7sDxPARjGCL1Qs9FDxchG4YBhrj8WBKEeh33797NXBSnjIwcHBJEti29DIC9kN2+qAEGq7qjKIrbDPNQe7lUGtocBQCiZK1xFzRNg2macB0HtmVBr1YnDkl3lK7xEinRzEXkGwW50TQNuVxODqSjrIhEuFpEDITmYtZmQ9euXcNuvY7f+eEPZ76vUevrReRgUBOuRwEyhRLVYcjn87EDaBTBDwK5Gp0lRGUNRXztB90PQr8gnliRyxcrcz2Xi9uz8+iCzZh0udR1HUtLS9ja2kIYBDKCMAlB8EQ6gUdeekHjkTphDDYxIRE/JAyyhI4DgBzPRMMmBuDOrVsolssozdgY6nFCRg4OASLHAfP9jpUxgI6owQLXGnQPK0mWHYYhmq2WtIftVZHQCwzcV30ACvk8Am4MZNv2wJKwNPujlMYqZ9+XtdMCYjWiqio03h1yEm8Ay7bBGNuLGMx4snZdF19//TXOnDmD+RmXmI0Kxtiex8EhixwIq+hZ+g2qioJ8Pg/bsuA4Tkw2Z3g/MKDD7nlUopiMkiGXQ9E0QbnVcBCGcVQsikCjCF78BpRKJTQaDURhiPsPH2J5aWmsCTuZTsjn831JuTBNC3jUb1Jy0DddSvb6fCQJgue6AOL0wvkXXsj0B1NCdhUfMWgQIHScnqkC4e5m6nrcOnnAdjzfjysSuII4TUUCgNQrNYI4PdFsNuF5HnRdTxWRkPtBTF5834/dB7vKtRRFicO+uh636yUEFtcYTDJ4C592grhWXEsIG5P54Gniyy+/BFEUPPfcc1Pf9qQQZXLC0vkwQeTpZ21HbOZycF1XTn6FKetBxH2VVNyLJllpuh4OQs404fk+TNOEiT3HwiAI9ip7+Cp/t9EA833cvnsXK8vLI7WvZozBchyIZmzDnnVN0xBwweekqYV9AmUxNvImTQIdEQTXRR3AjWvX8NQzz4y97wx7yMjBIwSlFAFvetT9KMmoQRRhcXFx4MPmuC4svh1d11EulVKF3mU4OuWArIv0guuibVkAIQP1BzQxcPlBIMPZYn8aJwO6rvfMf9NEW9dxEAQBHMsCQ0xskisK2VmOm6+wKXXXe/jwIW7euoXXX3sNhmHIssHDgsMaNQAwVGQ7td0gjoS1LQue6yLHo1STQoS++/Y6AXp21xwFpmliZ3d3b5s8Dy9y8WEYIgwCMMTVDY1GA57vY+PmTSwtLKBQKMAYcr7CXj0KQxBCZDpzEHRNg8P3T3i3xrGfpj7PoXSBRZ8Ug+ti8+5dlCqVrM3zFJCRg0eIyLaBPpOSiBrkeNSgFxiAdqJ5kpnLocibJw1DMoUxymqmUCjEAinfR7vdBimVOvK2Ec/lClIg98dXE7quQzeM2Mp2WOUEd4kbR3VNKUWbEwPTNAeqqBVCAFWVYrFxQSnFZ599hoXFRZw4IHvXUfUG0uPgMJID4EAiByAkFvPpuhS+jluFI3PhbHCbY7lrTEYQcrmcDKP32rauadA1DXnEn7WZy+HBw4fwggAPt7YwX6vBMAwQRYmfRZ6ySPZQaFtWPMkTIttdD4NwEY0ojbURuh6nUUY8v0FXhRECpSsiA+zXIFy7ciXWHxyQcdt3FRk5eESIXBfM93tO5DSKZF/z1eXlvtuwLAsuHygKhUJfwVA3ul0Ve3Ve6weCuLa63W7D56mMQj4PxphsVpSEwgehZLogLYSF7Mjhbxb3haeUQtM0FFNeF4I910UKjLz6uXLlClqtFn7vzTdHO94xkXQ6TAuRVjhsKQUAew6JByTgFL0BwjCMmweNmCYbFCXoBzkJC8fOEWGaJjwuwhv2blVVUSwWcdI08WBrC47jYKfZRKVSQc4wwDwPPjdjEqLGpACx1BVtGwZN00B52bPOtRzTbkbFeNUCuq59kiDYjoPL336LF195JdMfTIDDJVd+TEDDMC5b7DM4NHiFQs4w+gr/bF7rSwCUi8WRiEGyOdM4D6/QH4AQtNtt3N3cjMsEeedCTdOQLxRQrVRQrVZRKBSkF/soEGmFUSMHFldzEy7OGnkQ5vl4lX9Pc9y2bePbixfx9NNPo3xQjm0juCIKHFZ3RCBhgHNQ++HiRIUQuI4zkCSLckTKBZ10hL4evfZPVHWs9+dMMy57TkTlhkFVVRxbXESpVELBNOG5LlQePWEkbnTkBwG2trdR52mIvGmOPLFqvP9K0kp5VgLTXtvN8YgkGEN9ZwfXr1yZwZ4fH2Tk4IAh+yb0+z8vRYwo7at0F3XaQCyyy40gqNo30Y04QIVRBMu2UW804jw9/7vneTAMA3Nzc6hUKsibZmyyM2buMSkYHIVUeL4P13EAxlKHRPuCEFlfrfBue4T/rRufff45coaB8xcudJzDTDHG9kXk4DB0YxyEWesOBHKGAVXTwBBrd7qPgfIwNp2QEHSDYLy+FiZ3CnT7pBb6QVVVLC0sxJO+qqLebIIh7tFQKhbjUklOxlVVjT1G2m14vp/6nHVNAwX27Ms5lBEIQq++Er3AAGg8ypeEyU2aKGPYvHMHD+/dS7nnDN04fMuH7zgiyxoofms0m6DccKRX1MDzfSk+NPN5mKbZYWDUF30sitM8tJSnDDzP61gVKKqKhYUFqVL2eV93XVHGmti79ymd5VJuIwxD2O02GOKQ8SRd4vqBJFbrIrS8ubmJzc1NvPXWW4c6jCm7/eGQNVzikJ+yuG9mRK46tk3its7tVgu+58HgOXgKTE2kOuw4RjlLM5cDWNzKuDxiTT8hBIsLC9je2YHjutje2UEURbKnQ6lQQC6XixcwontpGMLhWqEcdyDtB9HOPKk7kP9LkWIQJc5pI30UCZtl/h7phGlZCMIQVy9fRrFUQiHTH4yMwzdCfIcRui5oEPQdcITWIAxDzCU6LwoEYRhXCSAWJqXNpQPoTQyG5EzF/nZ3d2FxkRIYg24YKJVKqPGUQaVSiTvdAWhxJ0UyaTkTpXF+UVFSDRaMCxAjxmAYBvKjXJtxICIKhODrr77C8vIy1tbW9uVCDxNkm2YRATmkGFVHMSlU7qUhyvcEMT2IazRqJY5pmiBjRA7k/gjBwvw8ioUCVEKwee8eGo2GLPUt5PMoFYuolMuxiFdRZNqh3W6j2WrB9by+K3xd16EgHjt67XvQszyox8qAE9p3DVVVlY6wlm3j8rffTqVr5OOGjBwcEKIgALXtgQOOSCeIcsSO90cRmq2WtDEtJqIKfRspjeE2RxmD47qoNxrS0wCIVwX5QgFzc3Mol0qx4jnB1sulUpzDBNBqt2WN9LigPB2RNvzdtm3ZFW4Sg6ZRcfPWLTTbbTz//PNxW19FiXUK6LTMnTbGubaHOWoAoGNiSFoOTxMM8YoTlMYElItexaQb8e6eBwkiIm0pIAyRxiUHQPy8VisVqadptttxj4TkSl9RYJomKuWyFCZG3OTIcRw0mk1Ytr2PBIiS5H6TsfSy6IVxx4seRM4wDOg8yrG9s4P1TH8wMg5vDPQ7BEpp3IZ5ADGgvClQGIY41tXaN6IUDU4MNE2L7X+73t9dHy6V9imZuB8E8DwPPm+JKmAYRpwqGBKiF+pm27LgBQFc10UQBCiXSmPlt0V+N81E5jhOh9HRQa2KGWP45ptv8MQTT3REesT+FQC0Kw0x8zK9AQgPexljAvIznOB6yXf2CN13/64Qghw3R3JddyYpqX4Q+oO0ZbQmFxWOC9/34TgOiqUSKOL7otlswjSMng3CZHmkaSIIAnjcxEwYmimKEosBRStnQGo0ej2/vbwshL5jZHCCI4TWSdKcz+cRWRYopbh75w6qc3M4trIy+j4eUxzSJcR3CxFvXNIPhJC4tjiK9kUNKGNotVqyDXEvYtAN6VA2ZJIMowi262K3XpfpALC4PXKhUMBcrYZSqZRqoBT7LJVK8QSNONohTFhGBUu5yg2CAA63Ry6MWHo1KTZu3EDbsvBsQoSYRPcnTgBZKSI+H9K1Wk6DcadLGTk4AuRgVIjSU/El9BV99Tg9ng0ZPYiig48e9DmmXhBGZKNCNFGyHQcM8aS/trKCEk8xbO/uDgy/K4qCXC6HSrmMcqkUp2IQL15cz0O92YTN0zKEsYHbImR/FdC493WH9Xpim4TrSQBI/UG71RpzL48fMnIwY4SuCzZgoBE3s+M4oJSikhAZMfBUA++jXuGhwEHbSVObHwQBms0mdnd34di2FAHlcjlUqlVUq9V4oEy54pe+Cfz3nGGgUqlA5cZCbctCm0/gaRHxQX6QGHGf0dEIdeqTglKKixcv4sSJE6j0K10ccr6ypC6hX0g6N/aLgIwbFzn0aYUudJ9n0lsgWUUQ8dSASEUkDb5GgUIIzFwORFEmCtuPi7QEYRxyIB1XgwAEQN40USwWoaoq5ufmoOs6GKV4sLWVqmJAU1UU8nlUKxXk83mZGhEN1CzHgWVZw595MrrXSs/NdGxy7zdNVaVttG3buHrxYqY/SImjMUocUURRBMpLDvchMYmHYQifi3yElkDk7sMwBAhBJU14fkgqIQhDNJtNNJtNuHw1r2kaisUi5mq1fRbDadBNDAQ0VUW1XJZhSs/z0Gg2ZWh76HZFD4B+5zym0dG0sLGxAduycGFAH/lJ7GO7iUMy2iCG7qSmIQ3xEh4Hh65VM0fHGfDzoT2iAB2vS+lDkRY504TCowfdKbZZQ37GQz7LHDdCSgMGSLvziFKoioJSqdThGKryqiNN0xBFER5ub6cuKSSEIGcYKJdKqHC3VE1VEYUhLK5NcF13oKU0CAGb1Ga86x5I3hOioysA7Ozu4s6NG5Pt6zFBRg5mCDaIGCTC/o5tg7K405gQ0ViWhYAPTuWU3RX7DZKSFDQacY8DxCVR1UoldkvL5SYaYPu9kxCCYj6PcqkUpxkoRaPZhJNiYBMriX6r3ImNjiZAFEX49uJFnDx5cuRysonBQ7ZAp2nQsPQEFQ1xsGcgk5ZUjHZ4ibbLiS/W43vHl/DM6IoAyPM6oM9XaA8IIbIj4UEijUGSmculIgeMsdhFlb/W0HWUSqWemhNd07A4Pw+VEPi+j91GY+RjV1UVeR5NMPN5+Tk7nhdXOQwgCZgwmtVrq8lnIs9TRpRS3LhxQ/rEZOiPjBzMCFEYIuqz8ujWAziOgygRNRDuh0BsVWykXM0TRelYafciBblcDnPVKsrF4sQueWnthQ1dR7ValcTHtm1ZmdEPwjq5F2mZqtHRGFhfX4frODg/IGoAYCYTWhoS1+sVEb+WiqrK1EWSVAyiCAyQyv5ek3ry5473JL7Q43vXiSV2+GhLQXO5XGyk8wiiB8BwgyRpoTzgOvlBgFarJXskFAoFFAqFgfePYRiYn5+HCsBqt9FoNsc6flVVoes6Cvk8TMOIhbmU9iUJURTJ+3EiDLgeiqJIF1nf93H98uVJ9/adR0YOZgTquj0fxO6wP40ieDylUCgUOtwPC4VC+jx6YpuDSEGJ5xknzfGN2ndAVRRUymXZHtcPQ9QbDVg8arJv+32aLiWNjvIzMjoahDCKcPHSJZw6deqRNHYZW7Q1RG8w6LMk4MSz18SS/NuMyNBB+0ZI7QH3E3gUvhWDBMVmLgcC9IweBGGIVrsNmz9XqqrGC4yUz0khn0e1WoWmqrJccZxjV7j/gKZpKHPb5l4kIblAIITIqNhY6FUZkUjTaJom0ymbd+9iN9HdMsN+ZORgBoiCADTlikMIETVNAwjZcz80TWnkMRR8EAnCEK1WC60kKTCMDlIwDYzjnyCQz+dRTaRJXM9DvV6HkxiEk7nlpCDxwI2OeuDatWvwfX941ADTD9kDGLtrZHTExIhJPArDJiOXg6KqcVv1A65cEOgnxs2ZJhjpNEKKogiWZcGyLNk4yTTNOI0w4mdeLpdjsaKiYHtnZyxxpsLNyyh3mTS4LqGbJNQbDbiJKIhofDZNJO/5nGHE4yAhuPLtt4fWsOww4OiNFEcAUR+zo16rAdtxEHETljbvuWAYRqoe6gKhiBTU6/B9H4znTeeq1b45xrFXoOIhnmDA1jQNVV4OpXKVs+04qDebsoZa7COZJnlURkcCYRDg8qVLOH3qFAojfD7TQiqb7D44apUKSTwKcqAQEofEH2H0AOhtkGSaJgggJ1WH90EIwhAEkOWGIsIwDmrVKsxcLlWJYy+I+4x2RQYEScibJmgUgVIKz3XRbLVkqmTsvh99PqOkdkXYKxNC0Gw0cHNjY7x9PQY4eiPFIUfkeT2Vt70eUkYpXNeNV/m8o6HORUNpEIYhmq0WGpwUyPRBrRZPvFNWpferTBgXhq6jWqmgUChA4auMtmXFVQ1B0EEMHpXRURJXrl5FFIapogazQLKvw6g4Kg2XDhNyuRzII44e9NIfiFRju9WKJ1UepTR0HeVyWYrvJtovIWOVOAqI+6xXypCQuCOkiCQA8f3pcpLg8m6zYxx0KvdFRVHiqCwhuLG+DnuM1MnjgGykmCIopYj6aA16wXVdhFz0JNzF0pgchdynoNFoIEhqCrhpkSpEZ1OcQKdNDAQIIcjncqhVqzKNEvKeDg6PFDxKoyOBIAhw5coVnH7qqZ4ucgeBieyoOWE9qpGDqa/cU2yPcO2Bwn0PHln0ID4YAPE94IchFFWVHRM1HkkrFApT/XwnKXHsFTkQYIyB8tRHMt0AxAsmx3HQbLUQjNARUqDv+MR1EAK6rsMwDPi+j/Vr12SZb4Y9HL2R4hCDeR7Q/TAM8B5oWxZsy5Lq6GHEIIoiNNtt1JtNBGEIijgFkSQFSfRdaY74wM2KGCQhwn21ahWGroMQgjAMsVuvY2trCyGlB250lMSVK1cQMYZz5849kv0DkznIDSsNPeyYeqQo5fZyhhFbG7O4+dCjAkFMUFutFlzHkWWfxWIRpVJpZoR5X4ljvZ7qfeI+665IYozJyhmB7nQDIUSShHYiMpIGg/RQDJ1jmJnLQVVVPLh/H1tbW5n+oAtHc6Q4hBBRg270Ux0zbi3sBwEK+fxA90MGyGZIvufF1qcDSEHXAex7WMZ5BA4qiK8qCorFIso8QuC4LlzPg+s4oI/A1haISycvX7mCs2fOSLe1g8awDpoD35sYoDNyMPp+c3zC8h5B9ECE21utVhxJ426mRFE6mgvNEh0ljjztNwwKFxaKUleBQf1FepEEyhhcx4mFyGlW94QM9kzoMhjL5/OgUYS7t2+jlVkrdyBrvDQl9DI86utWyBh26/XYylRRsLS01DcXHIYhLNtGGIagjMHgHRnT6gkIf1jYCH3SOw91tJLFaYAh9v/XDAMKbxOdM00EYYig3Y47xuVyE5s3pcXlS5cAAE8//fTM99UPk5R5HeVKhcOAnK7D465/vu93uAvOCiHflx8EcjIlqoq8YcDQNCgHXOJZyOcRVatoNJtoNJuxK+kAUa7CS18Zd7cUVuqikmIQBEnQdR2+78P1PETc/jnHo4cTPfeExBFeQqBy/cHO1hbmFxdhmiaMRxSdPGzIyMEUQCnta3jUC47joN1uI4wizM/N9TQ5Yvx1tiAd3PBnnHz3PoKQclB5FMRAQKiYTdPEYqUCXdfheR483welFLbjwHEcGLmcDA/OAq7r4tq1a3j66acPZFLoh8dBbzDMa4H2McUad19pr6jQHthhCNfzOtqVTxOMsbjroed1rJJVVZWdUWUHQkWZ2KtkVJTLZYRRhLZlYXtnBypv69wPiqIg4uRAUVWEKYhBEoRXXem6DttxEIYhPN7ttZDP93/mU1wXJXH9dF1HEIbY3dlBsVjE4uJi6mP8LiMjB1MA7RHq7hc1CIIArufBc924pK9H054gDGW9sqxgKBYn6qYnCULKcrhHmn9jDI7rgvJzN3M5QLi85fNwfV8OoJ7nwfM86NzgxND1qZrxXL58GYqiPNKoATC+3gDY0xsc6UqFKQtsR4Wh63A1DVEYwvO8qYpSKaVxu/Qg2EsBEQJD15HrRXy5uO5RPKO1ahVhGMJ1XWzv7mJ5aamv3kFRFES8MRbhLojjQFEUlIpF+L4fd32MIrRbrTiK0Ct6mGIBJPQH4lVmLhf7wywvw+WLkscdGTmYEIyxfc2V+hEDRils20bo+4CiQOP5dfl/xNbCjuvGQkZFQblQgDGlG1W4hTHGBk6gByFAHASPh1MVRYlDl10ufCaPFoScaAVBEKccuFWsSDlMulJ2HAfXr13DM+fPH7gTYxJCbzB2GeMRiRxIDMhJT2tCHHUryeiBx6uLJr2eQRDA9/0OHY3CtQSDtk/A224/IufG+bk5PNzagh8EeLC1hZVjx3oeq9AdBGE4FcGkwQ2MHBFF4M9+Pp+fePuKogBRhN3t7XhBkpGDjBxMCur7qR9S4YboBQE0VYXOTVaA2E7YardlfjiXy6GQz09/QFeU/RUVCTxqYkAZi+uOGYMp3Mz6QNN1lHRdrrykKYzrwnVdaLoOg5csjbPqvHjpElRNw9mzZyc5palgks9DVioc0m6MRwWGrsPTNIR8Uh9nAgnDMCazQdBR5qfpOnK8nDnNvao+grSC3DcvcXy4tYUgDPFwextLCwv7xiqVkFQag1Gg8AWV7/txdJFSWJYFwzBicyixrzTpUy5OFGNezjTx8MED1Obn4TjOI3FgPUzIyMEEoJQicpx4Vcdvxn4thgPf3yvJ4eU8tVJJToae68bhQr5aNgwjvrlnEEpVuAq4G4+aGACIey1EERRVTT34KoqCfD6PvGnC5znbIDEIW7YNXdNkbXMawmXbNtbX1/Hcs8+Ovyp5RKvcboj8db9qmKOCaesORt4/tyS2eDorzb3EGJOEIAzDfY6BumHsWfqOejwjv2N6ECWODx4+lCWOC/Pzey9gcattYaE8LYiOorquQ9M0aSLn+z6CMETeNEeO8kkdByHQCMH21paMHjzKVNajRkYOJgDjUYOkNWfP13EBHRBbB4ve9Lqmod5oxOU+AEzDQF4YmcyIGAgC0I8gPMpHwQ8CWapZyOdHP3+ucjYMAxE3lwqCAGEUybSD7TgyamPoet9B+eLFizB0HWfOnJn8xGYEBiD0fYRRhIhb0UaUgvLfI0oR8X4boiU45QY0lNL4Pfx1lH9FURR3FE1sS0RmGIDffPBBrJbXNKgk7vKo8i9FUaAoClRFif+vKPLv4m8KT6cpqhr/TVXjyhRFQRhFcH2/f0+RKeoOxk1RGLoOV1UR8LB2r9WlEBYKUpDcDyFETmxCYDjJ8SuKMtXJdxQYhoGF+Xlsb2/DsiypoWKMIaJUjmPTjnAQQEZARfM1x3Vl2lZM7ConEmm3yfg5bT94gLn5edi23ZH2fdyQkYMxQSkFTfga9C1bRNw3gFIahwL5oBtxkw/GGBRVRblY3GO8BxQuVAgB5ft7lJUJ8SHEvecZYnHQpAOK6C2fz+fjyc33EXJtQhhFCHm1g6qqMHRdDtgA0G63sbG+judffHGiXOa4ZyAEXx73d5BeDzxd4roufNftbFbF39v9GSanDZWQvUmcT8iKmMgJAVFVaKoap2P4z+K1ompDWOomiUXAy+6SZCIUPyeISM/JOPnMJCJXei4Hk4eKzXw+1pGYJnTDgGkYyJmmLDs7aC2FaZoILQuu5+21d6Z0L2XAy2/lKSqKjFylTRsMg8rFxcBolRfTRp53cZQljiLix/Y6qjJgL7o6JYjxljIGTdNQKhbhet7egiAM4/sjZRQhWQWiKAp2Hj6EYRhD21x/l5GRgzHBRLvUISv8gN+whBAUSyVsbm6i1W6jUCyCMoYCn8DkDSgGlVndkF0DtALEjmWz2VtqWI4TrzZE6Na2p3ZM0kvdNKVPvu/7CMMQURTBiSI4rhuLwXQdX3/zDYxcDmdOn55sx4m8J40ieL7fMcG7rgufayWSf0uWsUW8q52Zy8nJsFqpILe0FDtGmiY0TYtX78kVuaJA1TTQKIqjJZqGWrU69qns7O7Kks5arTbWNkTUIkoQh7ArOmFbljT6ESTItm3s7u7KyhQRrhZRu5xhSAIhrkn3zzk+Uex7zsaAoevQVRVeFKHVbkNV1bgxUWKbiqJIzYuwM58q+MQoqpAopY/sGRYljq12Gw+3t3Hs2DEYnASJigXhdTBNiNbQjD8jIqXgOI50WAyCAHnTHJ7+wR5BMHM5bD18iPmlJViW9Uhasx8GZORgDFBKQZNtRoG+LoginWDmcvBcFy3ub1AqFlGrVjtXpjNKJQyDIsJvYxolTQpRvwzGUCyVpLp+JnoLRUGOVzOI8K9YbVBKsbO7i5u3buGZc+dkqFR8DRpgROSj1W7HDXGaTTSbzXjC56rqjtcjtuYVE1ehUMD83NzehMbLtET6Y9zJxfU8qIoC7RCIERVCoGha30HHCwLkC4W4x0ifATkKQ9iuC0+QKV4WLL63Wi083NqCx/uWAIjTEXxVmOfX19B1lMpllMtlVPj3YbnqMIriFE4Ywg9D2JYFyu9ZhU+Ew9JV00KylFFMwuO2854GqpUKHM+Ln6GdHRxbXJRGSAQxyZ3FNRFjr7gWos+Ex8udRZ+WYqGQav+CcOi6jgf37kHX9an3rDgqyMjBGGDJdALp3wnMsu047MVXFrZtg1GKnGFgcWGhc8A/oFRC915EWSMBwGbQS33o8TCGNk8nGNynwOGD+qxpinBiE+LPIAxx7epVGJqGlZUVqVMQECF5j69mLctCixOBdrsda0kQD1Dlchn5fB6VahU5sYrl3/OmCSOlu+Ok+eSj2Kp50FVRuTNfmpbZgnSKyIyXiM60LQu3b92CzfsUMMTpgnKphHKlglKphCJvZqRxA5/ks6ESAlXXQXi6cKiN+ZRBup5VAoCNYHA2TVDE12++VsODBw8QhiFa7TaqlQpURYlTSjMmLqSLLJm5HHRNg80rGtqWhUKhkNpuWtc01Hd2cGxlBe12G5UefjTfdWTkYAxI06MBK32hmAd3CKOUIgyCeGXRr7Ruxqv2bl9z1rVPoQRG1+tmCYev8AghA+1YZw5OkO7cvYtzTz+NYqGAeqOBRqOBVqsFq91G27bh8ggHEIuXSqUSarUaTp48iUq1igonBYQQRF2+8qNC+htMcF8cKXKQ8lqlFRNqmgatVEKxRxSCUQrKWCzYbLdlpKfZauHBgwfYWF+Xeg1VVVEsFGSTo0q5jEq1irlaDR5PLx709SVdVQCEECjo3SJ5VmDoJK+6rqNarWK3Xkez1YKZCOfPUjQp74cuciQ+N5v3pLAtC2Y+P7R5m6IoIJTC0HXs7uzEVtEjWNZ/V5CRgxFBhdf5AG0AjSLpaUAphYaY6RumGRuodIcvDyidsG8PPfYrJqKDSDOE/DqBxa2Y95XaHcA1sW0brVYLrVYLt27fRhQEuHr1Kr759lv5mmKxiFKxiONra8gXCjK/3R2GJryu23XdeCDh6vpxJ3eRB50ER4ocCAw75wlXyIyLKCMuTlVUFZVKpWN1yAAp+rRtG7Zlod1uY+vhw9hsC3yFWiggb5qoVquo8UZoaVIUk6KDyCf+Rg4wvdBrwi+VStJnZLdeR7VcBjB7x1XxnNAu/RQhsbOqw22XXR5JMAdE7hji50XXdVjtNhaXltBut1GdQLNzFJGRgxEhowb9Bn3GYNl2rJj1fZjcA7xYKmFnexsU6Bw4Dpjpd/w8YBAmhMw0zZBMJwgFesexzWC/7XYb29vb2Nnexs7uLtrtdhzyBGTONl8o4MlTp1Aul1EulfqGi0X9uvziavxkKkKkGUQpn0hLaLx8b+jEP4VrIMnBEVr1DKNDBEhFqFlX1YT8me3vFgjwZl/iS9Og9BFeCu1Qs9lEvV5Ho9HArVu3cOXKFZmiECr++fl5LCwsYI5XeUwLpA9B6kUapg0KDCQg87Ua7j98KEWKhmEcSDUFAfZpL4QmoZDPw+UpQZ/3ZykkheB9EHE9kihrnFVr7MOIx+dMpwThbdBvYHI9D45tw/O8+GbifREIIVL0tq/r1wGLAEdpODOrNIPLxUIE2J9OYCzOn04ASil2d3exs72N7e1tbO/syFr9SqWC+fl5nDxxAuVKBeVyGY1GA79+7z288cYbmE+aufSBqFcXAz5jDFEUSaIQ8UkIicmpW5RIBFHgxCHpFQDs+b+PC8YnQeCIGCCNcI8R0SeEn6P0ZeAeDZSnDfpB4aWbqqpC1TT5OaRBjosaFxcXQSlFo9mUk41t22hz4tBoNHDlyhV88803IISgWq1icXFREoZ8ismp7/n3MRcSE+QswvjdaYR+UHllzM7ODqyEv8tBoJf2QmpKeNmpY9sIASlU7PW5i8iQpmlwLAu6rqPdbo9dqXMUkZGDEdAdNeheeYRhiHq9Dt9149CzaUozHzF5ANgjB4+oOmGU/c4izRBxsxIwhkKhsK8hUL+a/UHwPA/bOzvY3trCzvY2dut1WT41PzeH06dPY35+HvMLCz27YH78ySfx/1MQg14QA0lyEIx47Xu3MRHlUQZGKYJeAzxXnwvHTEVRpBoeXE2dZiITVtwkQTiOEkSTMJaY7KVWQJg1cYLQD/uMmHip57Ry84qiIKfrcLkZVa1W2zeBtNttbG1tYWdnB/fu3cPVq1cBXnq3sLiIBU4WqtVq6s9pUFfGWaQX2IhmRoVCAa7rIuA6joPsVUBEmWfid3GPGLoOpViU3jN9KxkIAXh0ybVtVGo1GT14lH1WDhIZORgBUm/Qq2yRUmxvb8Pn3RbLlUqH01sYhh0tQh9J0xQ+2I4zwU8zzWBZFhhj0AY0OBlkKgUArVYLWzxFsL29jXa7DQDImybmFxfx/PHjewPukPNtNJt4cP8+Xn/jjXFPqS9ERABdA0qy1j8SzoSCNPCUxcA8LSeogjyIn0mCPIhUh3rIogbJSV6G+CmFw3P8vrAaHnD+yVUsAfYm/qTzIr8evUB4OmkaMHI5WTqX72G5W+LpqVOnTgEAfN+Po1k8onX3zh0wSqFqGubm5vaiC/Pz0PuI51QueO2HaVUvMPE1xnZqtRosy4IXBGi0Wn3LU6eNXumFJITA0LbtvUoG7rQowcd5hRC4jiMdZVut1tgLiKOGjBykBKU0Tin00BqwKMLW9ra8iRYWF5HL5TpeI2xUZSnNIxiwJxUFTSPNkKz571udwAWf4gqFUYT67u7egLq9LbdRq9VwbHkZFy5cwMLCQhypGRHXrl1DzjSxtrY2zimNBZWvZLtJgxCxBmHYsWIWfwd4vpeTiIhSRL12AMgJS9M0aaYkIOrPRZVGsiS319+FKt/z/dhkhm+HJcS5sh24WPHznyH+xga3CxciwW5r717kR5yLqqogA0hAP0yTmmuaBk3XwXhfj2GrZMMwsLq6itXVVQDxZ16v17Gzs4OtrS1cv3YN3168CDCGaqWC+YUFLPIIQ4GnKImigCbKbLsxjeoFluIzGwRFUVCr1eBsbsLlws40JahTQaJ6ode4p/I20LKSwbZluXEveK4LPZeLjbl4V87vOjJykBaizrlrEIqiCI16HbZtQ1EULPYgBkA8qDJK4/bLjyKd0KPUZxx0pBmAkVINoskURUwM+hnzBGGIhw8eoNVuo9FoyP4TmqZhYX4eZ8+excLiIuZrtYlzmV4QYGNjA+fPn9+X3pgU4/j3yzTCEMMl0Z+jI9wu/ib+n9hm9yA56l0gyYHnwZ3CwKiQ2NlP6Z70EXckLRWL8aSP/hUbg1bOwzBty+GcYSAMQ/hBMHIIXVEUmdISHUAty5KRha3tbayvrwO8fn9hfh71RkOWyvaNjvRJfw5DWm1BGuRyOZiFAjzXRb3ZhME7T84ayeqFfuOtqGRwRSUDd980c7mOe4MQgsbuLk6eOSOrmxYWFmZ+Do8aGTlICep5+6IGge+j3W7Dsm0oqopatdq3zWcYhvsrFQ4KM0hhSJIwQqrB4o5ymqLsG0Btx8Hdu3exubmJBw8eIAhDFAoFLC0u4sknn8T8wgKqlcrUjZE2NjbAAJye1Cq5Byb1OBg06KepudY0DT5P3eSSA15yRZggDcmVfvf/NX7fGrqOXC7XEVVIpoBkE7Lkz+I8RGknek/4Lo8YaCkdBsdtniTPdYrQdR2qosj+CpM+58ViEcViESdPngQQRx53dnaws7ODzc1NWJaFKIrw//7f/8PK6irWVlextLS0j1QSRQGL+sWWOiE+76l6JRCCcqkk02S7jQaWDmhiJdhzf+3XzZMQgnw+L83NRCWDmVzgMQa73ZaNsoSNd78ow3cFGTlIAUopWFcILwgCtNttuK4LhRAUuEFKP4RBAMpYHI56VDngWZEEMUgP2L5oqwrG4lUhgN16Hfc2N3F3cxP1eh2EECwtLeHChQso87rz4gx7qlPGcO3aNZw4fnwmD/q4k9e0mtQIz3mpe5gAot24FNnOEGnPfNqr/0kg3DYj3iNi2osAXdexvLyMMAxx+fJlaJqGSqWChYUFbG5uYv3aNeiGgWPHjmFtbQ0rKyvxZAakEieKKNS0xybCv6rlctya3vPQbrcPrF9BsnvloGdRNNCyHQdhGMKhdK9lMye19e1tlKpV6YyakYMMkhjIUBX3VReCr0KhgFKpNHBAF8w5d9CRg+QDMYW0Qj8MIgmUxX0HIkrh2DZu3bqFzc1N2LYNjVsVnzt3Lm7YYhhwHCcWLc7YzGVzcxO2ZeGpGQgRJ8G0PiERdj8qzm6HZaIfF4ZhSMfPMAynHj6/cuUKvvrqK5w4cQKWZaFQLOLFl17Ciy++iEazic3NTWzevYsPP/oICiFYXFzE2toaVldXYZpmz8mxI4Uwg0WLiBTpuo5KuYxGqxWnF0yzZ9XQLECGEAMBXddRVJQ4wkkpwAWmAADGsP3wIVaeeAK2bcPnTdQOsgrjoJGRgxRgfNUEQKpbI0rh+z4K+XzcIGfAjS6V14nw7IHgUVRECNEiP98wDLF+8yY279zB1vY2oihCoVDA6uoq1tbWsLCwsG/ykimLGR//1WvXMM8NamaCR3D9O3cf7//ItJwd8Xr1MwIavpvZfC6KoiBnGLJ18DTJwWeffYb19XWcP38eFy5cwF//7Gd72yexh0K1WsX58+dh27aMyH3+xRf4/PPPUalWsbK8jLW1NVS40x9L6FJmCUbixlelUgkOvzb13V0sLiwcSImtSHulstxWVRTyeViWBd/35WcKQuA4DjzPQ6lUQqvVQrvdzsjB4wxKKRj3/meMyYiBz1mlym+mQZCVCrr+aOvND2iycl03Hpzu3sXmvXuIogjFYhFPPfUUTpw4gWq1OnDCGtTMalqoN5t4+OAB3njzzdntZILJa9Kzp7yiATg61snj3J3jpG5meWcZhhHnpH1/IpMjgTAM8dFHH+H+/fv43ve+hyeffDL+exD0XZAUCgWceeopnHnqKQRBgPv37+Pu3bu4wm3BTdPE2uoqVjk5n/n9wWJTM6IosXvi1haCIEDLsqS98swxwj2i63psde+6cB0n7mqqaQBj2Lp/H0+cPIlWqwXf9xFF0ZGJzI2KjBwMAUt4GzjcFhmUxhEArnYdNpHJSoWDzFH1ehhmlVZgDE0e1ry7uYndnR2AECwtLuKZZ55BpVpFrVpFkZdhDUOH0nhGEOWLopzssECmZSacVMS1G6fM71FjlKMdR3cwy4jUqGWNg+C6Lt577z1YloV33nkHS0tL8n9BEKSKQuq6juPHj+P4E08gpFRGFG7fuYMr167B0PVY0LiygmMrK6m7FqaF/Cz5Ndd0HdVKBfV6Ha1WC/lc7kDKAglvppT2s8/punQ1tRwHJW6UtLu7i5OnT8MwDPi8rPeg9BMHjYwcDAELAhBC4pavvh975WsaQCl0XR8eOmQstk3GAVYqHESEgDHs7u7i9q1buMvV06qqYmVlBU+99hpWVlbAEJsVAXHpYjJdMDRygNkN4p7v48aMyhc7MOakPI3JXPZUOGLEAMDsBbsz1N4Ak5U1CjQaDbz33nsghOBHP/oRyl0r7DAMh07ksgqFV54QQrCyuopjy8vASy+hXq/HOoXNTdy8eROqouDY0hJW1tZw4vjxmY1XpWIRLje82qnXcWxx8UCiFwQA0ogz+XczlwPlBmW246BYKMDlpYz5fD4jB48zaBCAhSHCIIBj29Kf2+U13/k0ngWESJ/9fm5nB4VpTLZBEOD2rVu4fv066o0GzFwuVkevruLYsWN7DzljqDeb8TUzzZ6Nf/qRhFmTg1mWLyZBHqHm4Eh2YxwHhMiqjNRvmeHhAJOXNd6/fx8ffvghSqUS3n777X0EQzQL6xc5GFSSKASCjBDU5uZQm5vDhWefhW1Zkih89umn+PKLL3Di+HGcOn0ac3Nz4xPWbl8UjrlaDcGDBwijCI1WC3MH0fFQRA9SvpyQ2OLasu0OgnDnxg2ce/ZZNJvNuMHeDMSnhwHfvTOaIpjvg0ZRrJxHTAykR7dhQOV5qGEIebXDvlbNs8CA4xl7UORRgo2NDdy8eRM0irCyuopnn3sOy8eOgfSYgDzfRxSG8gHrOI5E/Xuynr67Ln4W5IAyhqvXruHEiRMzL0Ua5+indc5iddTrsznsGDWtIGrZ0+Ig2gePW9a4sbGBzz77DMsrK3jj9dd75rPDMAS4hqkD/FkaVpKoKMo+A6lCsYinzp7FU2fPwnVd3NjYwMbGBtZv3ECtUsHpM2dw4uTJkdMO4ii6r7jKfWG2eXfUfC43c3GfIEWEE8p+SP5PURQpUIyiCI7rAvU62q2W1Jc4jrMvsvNdQEYO+oCFISJuckT5g2gYBpo8TJ72Rha++RAeB7PGoEjGiOHUMAhw69YtrK+vo16vI5/P49y5czh16hTMQSJMxmKLXcZQ4AYj/SBXMvKtbE+QKMKhqY94OO7evQvHtnH2qaemuNXeGGe1Na3zPYqRg7Gn7FHTBIoSO57OEOOUNX711Ve4cuUKzpw5g5deeqnv64IgAAiRE/U+m+Nh913XM9cN0zTxzPnzeObcOdx/8ADr6+v47LPP8OWXX+LEiRM4zaMJkyJfKKDourAcB7v1OpaTkcdZQOhwgIF9J5JNm4CYyBQKBVhcc6YoCm7duIHTZ89m5OBxBHUctFstRJRCU1UUi0U4tg0gzimmVaj6PAUxSkvYsSBu9EEDQ8oBtF6vY/36ddy6dQtRGGJ5dRVvX7iA5eXlVCtR1/MQRREUVU1NoronUgLeoGdKhkACV69excLCwoG0Xh3ZtnYKVQoCIqR8pDQHB5WGOYD9jFLWGEURPv74Y9y5cwcvvPCCtFDuB+GZQlR1bAvpXtGDHi/C8soKlldW4DoONm7cwMb6OtY3NjBXq+HU6dM4ceLE4GiCuP/6XPNKtQrP8xBEEXYbDSzMqqwYnZUtCoBeZ9+PnGuahrxpwvU8uK6L3Z0drDoOCCFTc8U8bMjIQQ+wIIDVasUTHCEoFouglEqXuFxywuvFQBOr9zAMQSmFdggadQwaEqMwxK3bt7G+vo7dnR2Ypomnn34aTz75JPIjNEthlMIVUYMeHeqGQfjBy4jCFJT7Arv1Ora2tmZbvpjAqEc9zSnrKEYOJEa9ZzDatTsoupQzjLj51YCyRt/38Zvf/Ab1eh1vvfXW0OoZhjhlR/miZWwQsq/B1SCY+TzOnz+P8+fO4d6DB1i/fj3WJvBowpnTp4cT7h7PsqqqqM3NYWt7G7bjIJ/Lzaw5UwdZJ30aUw24HoZhgFIKPwhg2zZubmzg5OnTsbjScTJy8DjA2t2VjWZKpRIUVYVtWQBSRg0SD0DAWf5Mb5wJyt8ajQbW19dx88YNhEGAldVVvP3226mjBN1wPQ8RpVBVdaKcvkIIqNh/8rwmWPVdu35d1ngfBNion8cUV7TSAOkokYNE2HcUEEJGagB2UDJRVdOgaxoYYz3LGtvtNt5//30EQYB33323f6ie+wSIMlfRkXTSssOxTKQUBSsrK1hZWYFj29jY2MCNGzewvr6O+VoNp8+cwfHjx0cS6JmmiVKphHa7PdPmTMmqDQA9oxoRpQPvv1wuB8oYwijCwwcPML+0BE3T4DgOKpXK1I/5USIjB13wbBuebYMxhmKxCFXTEEVR76hBCojueDMrmUuTTuhCFIa4ffs21jc2sLO9jVwuh6eeegqnTp+eiLUzSuG6LhhjExvAkMSDm9wKG5MouJ6Hmzdu4MKFCwe2mn5UAX3GmBRVHam0gsA4x3xIz9MwDAS8r0iSHGxvb+M3v/kNcrkcfvSjH/V87oSWgP8i/x6G4cBqhdQg43VtFMgXCrjw7LO4cP48Nu/dw/r6Oj7+5BN88cUXOHnyJE6fOiXdGONT6J8irJbL8HgKptFqzSS90GvfCiGI+BiTRu+TrGCglOL2xgZOP/00oij6zrVyzshBF5x6HYzErVGFaZHnugCGRA36TNJszNXQLNBoNHD9+nXcvHkTvu9jeWUFb775JlZWV6cyYTquG4c7NW3iSgBphNT998TPoxCF9fV1AMCpU6cmOq6RMI7mYIoeByDkSKUVJqkiGGmSO0AiofMOk2Fi8rh9+zY+/vhjzM/P46233uqIKjJgaB1+EARxq+spOPNJ5f4k10RRsLq2htW1NTiWhY2NDWzcuIHr169jrlbDytoaji0uDj4ORUGtVsPDhw9h2zbKxeKBTbSqSK+kvH8IISjk82hbVhzt2N1FtVaD4zgZOfiuwm21EHFHRKHGTxU1GCK6ARArpKeNtALDRgPffvMNbt+5A90wcPrMGZw6dQrFYnFqh0ITWoN+batHQopyxo7hLFnO1vWeiDFcX1/HiZMnD7aT2ggD7jSFl0fVAEl8auNch5F0BwfoPyHLGnk74I2NDXz99dc4efIkXn75ZdktcBRiFIbh1NKUhNsaT6u8M18s4sJzz+H8hQu4t7mJ6xsb+Pbbb3FFVfHMM8/gzJkzfRdYOcNA3jThuC7qzeZQQjEtMED6ZaSFoigwNA1+GGLzzh1UqlW4rotKpXLkHEn7ISMHHIwx2M0mgFh8I3K1bpqogUCvmyKhjj1otFotfPvtt7h1+zaKxSJee+01rD3xxExWk47jyFDnNNiz9DoY4YGVV58kmj8BuHvnTtx98QDKF8fFNGvvj6wY8RGaRs0ShmHAtm18ffEi7t69i2eeeQYXLlwYmRQIhEEw1Zy8QkhcuTDFSY0oClafeAIrq6u4/+ABNjY28NVXX+Hq1as4f/48Tj35ZE89TLVSgeu68D0Pjuvu80iZBaTfyoifhZHLwQ9DBL6P3d1dzM/Pw/f970wr54wccNjtNmgYQuFMH4DMIwEpfA36CAIZ/5o6mxwgQrRsG99++y1u3rgBM5/HK6+8gpNPPglCyF7IeYqIogge1xoMa0KVFkqaaMwAEEBem/WNDSwsLqJWrU69NHLoMaR+8fQsfY+kGBGJyMEY7x23Q+NBIIoifPnll3iwtYVnn30W555+eiIyOPWyOZ5+mkUvExFJPH/hAp579ll8++23+PTTT3H58mVcuHABJ06c6HgeNV1HsVBA27bRaDanTg76RZiEtTJGjB7keIOmne1tzM3NwXGcjBx8l0AphdVsQkFMAsTNmowaDM3vKUrPwYmKZh+zmJC6tuk4Di5evIiNjQ3ouRxeeOklnDp1ChqfJKZPC/b2SwHohjHdcOeIzne9YLsuHj54gFe+9z25XYATNq4CPwxBwKl6HBzRyEFqE58+SK07mCGJEJ+jWBTYloX3338ftm3jey+9hOrc3MQENYqiqav5Z0WuxJijIK78ev311/HM+fP49ptv8Nvf/haXLl3ChQsXcPz4cfmecqUC23EQhiEs20ZxmqWNPc5TuEoqhIw8Rhq6Hkc5LAu2bUNV1QNdgMwSGTkAYFkWSBhCVVUY3CJ5rKjBgAdsljeL63m4dOkSrl+7BlXTcOG55/DUmTOT1UGnRBiGsdHTFKMGAOQEMelq5vatW4Ci4IknnujcPN9H0t41rWJ5FKTJhU+rE6OANEA6YuRAYNyrMKrfwTTQQUZ4qZz4S71ex/vvvw9FUfCjH/0IDPHzEoThRFbqwZTTCgBG9j1IDV4amBz/KuUy3nzzTdR3d/HNt9/iow8/xKXLl/HchQtYWV2Fqqool0potFpo8ujBtO7lbvLIWKIHhXgGR7gGBLGtvu262N3eRj6fn7gb52HBY08OoihCu9GADsTld4gf7pGiBikG9amKw/jN6wcBLl++jKvXroEAeOb8eZw9e3bqbVcHQUQNcrncVAesafVXuHHzJtZStKIlXd8FZIh+xiuBaW7/qAoScUDXeiIkbIoH3Zv379/Hhx98gHKlgrfffhu5XA6u6yLibYAnJQezaP9OCImjaVPcZrJ1eDdqc3P4/ve/j+3tbXzzzTd4//33UZufx3PPPovFxUVYloWAUrQtC5Up2RN3R5cI0EEGiKKAjWitres6VN+HzaMHjuNk5OC7gFarBYVS6JoGQ9NAMaLWoBtdzHMUQV0qMIYgDHH16lVcuXIFEaU4+9RTePrcOeSGDDjTHnLDIEDg+8C0KhQSUMSqfgJy0Gg2Ua/XceH8+bG30T1RCaHjYZ7AJDk4gMjRVDHpqpWk69A4yl6SE0lS5DoI6+vr+Pzzz7GysoLXE82TdF2Xdsr5fH5s8haGIQpTrDSSmND3oBfSkOuFhQW8++67ePjwIb7+5hv86le/wtLiIk6fOQNCCFrtNkrF4kwiYd0W0iLVmPpe5NEGM5dD27ZhWRby+TxqtdqhHiPS4LEmB0EQwG63YTDWIXwZKWowBNNceUZhiKvXruHy5csIgwBnnnoK586dgznKKmKK4WubVyiYppm610RayHD/BAPVrVu3oGta3L9+SkgKHYHOdERP0pBioJn2YCw7Mh6xwWlizQHSdWjsXh3vu/4TrJ6//PJLXL16FU899RRefOGFjnNRVRWaoiBSFARBgNyYVT1+EExugNQH09Ye7HMlHIClpSX86Hd+B/fu34/TDR99hNr8PFZXV6fW1rmD7PVLAY8SPeDnpfHFZWN3F/l8Hq7rTn3BdNB4rMlBs9mEQmmHXWcYhuNHDQQSD5hUYE/AemkUYX19Hd9cvIjA93HqySfxzIULKIx4fN0T2yTwfV/auM6k3EiIKMccqBiAm7du4fjx47Nzp0RXOqIHaQCGexhMU+eQNECa5XnPBFMg0oNWvkIsGCX2NS1ilmye9OKLL/Ytm9UNA0EUIfD9sclBGASzSx0SApW7Bk4DjGsOUkdJCIntmZeXcWdzE19/9RUufvMN7lareOH557GwsDDR8QhdhRAh9jyEUaMH/LW5XA71ZhOWZaHRaGTk4KjC8zx4jgODUjm5MQCu4wBIETXo44go0XVzjTPcMQC3bt7EV19/Dce2ceLECVy4cAGlSUKK01gZMAbHdWXUYBbhazGYjJuW2d7agtVu4wSvUjhoiM9b6WEw0x2enub6/qA0EtMGm2C13rEdkVpAIqrTHSmYcqrP9328//77aDQaQ5sn6boO4jgIwjDuQTIigWOMTUQsUkFRQKJoOp+HuPaj3o+E4Im1NaytruLbixdx48YN/N0vf4nja2t44YUXxp54pV5kyD0wTnpFVVXkdB3bDx+iUCjg2KxbUM8Yjy05aDab0KIIZi4nH9AoiuDz1fDQqEGamz15g434cDiOg08//RT3Njex9sQTePadd1AulUbaRs9DwuSKbs/3EQaB9BmfBZQJIwc3b91CPp/H4gG5rI2CZJRBlrqK/yXC4mJiE39Pg6NaxphEvzPtFpL1ujNE5YecBHptc4qptXarhffefx9RGOJ33n0XtSE9ARRFgabroIjTmuqIwkLXdRExNlKn1HGQqqVzCkzaOpwQgqeeegqVchn3Hz7E3Tt38NO//mu89OKLsXfLGNtMbXg0xkKqUCjg4dYWWq0W6vU65ufnxzjCw4HHkhyEYYjA82AwBjPxkDk8amBOGjXoeOloDwcDcOvGDXz2xRdQFQVvvf02VldWUr33QMCYdEMsTLHEqBuKokhyNeoKK2IMt2/fxpMH2UehD4bmv4F991Hyt+6qjX3eD133YnQEyQFDYoXZI4IgPCm6/9YLhNeq9yUY8YvGPtYktre38f7778M0Tbz74x+nXs0aur7XjGlEcmDzMWqqZcO9MC1xIp+IJ4lk5QwD+UIBx5aXsby8jLt37uDjjz/G7du38b3vfW/kKEIaIzjxXI7qm6EoCkzTRH1nB61WKyMHRw2e50FhDJquS1vjMBE1SNV5cYSbPe3DkYwWnHjySbz4wgt7VsRTygFO+sC7nocoiuRDMCsQ4dpGaRwCHGGyu3/vHjzPw8kTJ2Z2fGkx7FNP+0kk7x/S+Y/O7fGVM+mKWkkRXtJ5kv8sJl6W/J94rTD16arh7z7ufSv57prxPquwfYJOcX5jpl1kTX0/sdkI2xqE27du4eNPPsH8/DzefuutkQSCuq7H2gdKEUXRSGJex7bBgJlHDoC9joWTYFAp4yiolMuyFPTZ557DE088gU8//XTkKMLIkci00YPE85TTdTTbbdi8u+9RS/EJPL7kgFLoCdbueR4YRtAapEXSYKPfS9AjWpDMW07bmGRcMCabKxUSTpKzgoi2jPpA37p1C9Vq9Uj0V5/24EG5R76qKJ3b7XaC7PofkJg4e/0vQRx6kcuen1DydcMm6zHTb/222e+OmYYA8dKlS/jmm29w8uRJfO973xv58xPNmJJljWlhOw50TZtZtUIHJo0eJO6VSe9xXddRKBRg2TZazSZWVlbwez/5Cb748svUUQTG2Ej28SNFDxIOubphIKQUlmUd6V4LRyf2OCUwxuB5HghjUvHLEOf/wFg6c5G0N3oipaCoas8B0nEcvP/ee/jtb3+L1dVV/N7v/d5sicEE23NcFyGlsfDmAG54QdLoCKYkfhjizp07OHHy5KwOa2qYxapiXI3Lo8ZUW5sPOvcJrgtjDJ988gm++eYbXLhwAa+++urYn5+u61AIgR+GI02+jm3PPqWQwCRGWtL5E9P5XCvlcnzNogiWbUM3DLz66qt46+23UW808NO//mvcuHGjLzGMUnhgdCO1RivxGaqqClVVYfHowVHFYxc58H0fLIqgECLthUP+gCqKMthyeIKJVeEruWRYdmC0YFYYs1qBURr7P7DY8OggQmXimo0S2rx75w6iKMKJQ5BSGIZpiEO7wY6g5qAD04gcpPA6GBVhEOCDDz/Ew4cP8dprr018f+maFtfTh+FIvRJs2z7YErkJogeip4xM9UwIVVVRKpXQaDbRbLWkrfLQKALXLUl9z4jnoijK8AqXru0amgbbsmBZFuaGiFQPK47oCDI+ZEohEZbzfR+MsdjSdNiqY4SbfF84nL93aLRAYAbphHEfUdfzQCmFpmkHFiZTeahulNKzm7duYXFp6UBavabBoOs9i2TRUbVOnmYJ5rTP3HEc/N0vfoHd3V384Ac/mA7xJASGroMQIrVOaWA7DvKzcEccgHGJJk1qSKaEUqkEjU/WbcuSfx8UReiouphVirZrjDIMA47rwrbtmXTCPQg8duTA9/0OciBSCgzxDdYXiRBZWjBK5QSgKIr0LfjpT3+K3d1dvPX223jt1Vf3RIfd+zss4KkYxtjI6upJQETkIOXDZbsuHty/fyiEiGkwi09Ylu4dNXJwQNsbdQVcr9fx87/9W0RRhB/98IdTLY3VdR2EuyWmPa6DTisIjHU/cRHrNFuHK4SgUqmAEIK2Ze2beEUUYWVlBb/97W/xy1/+UlahiWMaFQTDz6F7q7qmAYyh1WpJU72jhseKHFBK4bsuFEAKegKeUlATaYaeGDFq0I1ktGBtbQ2/9//9f/3TCIeJGCC2axUVCrNo+NIPqihnTEkOZAfGRPvXQ40pf86U0j2dy2OcVog303s7o0xy9zY38ctf/AL5QgE//OEPUZpS8x8BTdNkiW4QhkNfH0URPN9/JORgnEgU7dGRcRrIFwpy8m20Wvv+rxsGXnvtNbz51lsyirAhtAiTaCgG/K/7HBVFgaYoaDYa8Dxv7H0+ShzREWQ8eLy1sKaqUPmHGXBWpxlG/xtnzEFc+NxvbW3hp3/913vRgtdei5sk9dvuIVv1eaLXRC53oCtShacVhN3pMNy8dStVB8bDgmn2VAD2UgqE54mPEqYqSBywnbRX/Pr16/jNBx/g2PIy3n333Zml0kRqIUiRWhDitoMoY9yHMe4nUfo67XtRIQTlchkEgGVZCHsQK8YYlpeX8RMeRfjkk0/w3nvvdUYRRgBBCsKdOE8hSrTb7bH3+ajx2JEDhbGYCCBRpYBYQNIXY97cnu/jk08+wfr6OiqlEt79nd/Zixb0G8DHSF+Mgu4a8mEIeYvZg04pAFyQKNwrh0QPGs0mdnd3j4QQEZjNoHlUrZNngb7XYNi9zxi+/PJLfP7553jqqafw5htvTL2pWBK60B34/tCS3QMzQOqDka2eR+2rMAIK+Xxcdk7IvugBpVQSZUPX8dprr+EtEUX46U+xubk51j5HERATQqBpGjzXhWVZiEZsA30Y8FiSA7GyFCkFQgjUfnXDY07Unufhg9/8BhFj0HUdOzs7+Ou/+iv87c9/jm+//Ra7OztTbbgzK3iuCwrAyOUeSQvgtD0WRAfG5cPkJsnR8zOeJgHk25KRg1FTColj6XVUTERvuoyQBm4S6ClG63u/Tzty0G9CGjBRRVGEDz78ENeuXcNLL72EF7q6Ks4ColOj0B4MgsMjB+ajbOgzwn07SkfGcVCpVkEIges4Mq/fzxp5ZWUFP/nJT7C4uIjf/OY3uH79+lj7HCVdp2kaFEVBvV4/kqmFoxF/nQLCMETk+8gBsmxIpBT0KRuKtFst/Pq99xD4Pp5/9lmomobl5WVsbW3h/v37uHr1Ki5++y0Mw8DyykpsC3rsWFwtcRBIa+VMKXyeijnoqIGAoqoAb1LT7+owHEwHxrExZvkoWNwdrm+IXESZ+PbFYKyMU3o2hCCktS9Oohed6/c+sWpOkg+xUiMYbdU28Pj6XBfP8/D++++j1WzirTffxMpBlBVzpO3UaDsOTNOcqsBvJAjX0pT31rTcEfshZxjImyZs10Wj2cTiwsLAygBD1/HmW2/hyy++wGeffw7HtvHsc8+NRF5GuQ8VRYGqqmhxclB4FOmgCfDYkAOZUtA0+QHLlMKgKoURWe/29jbef+89mLkc3v3JT7C9vQ3P86BpGp588kk8+eSTYJRie2cH9+7dw/3793Hr5k0AQG1uLm5XurKCarU6s6hC2hvc46FOTdOmTqDSQuWT46DIwfb29iPtwDgM++rE+6xuBCif9IUN8MDPKnF/RgnNwVFDrx4kSU+QQZO98DVIkohRatqTzZPe/Z3fQa1WG+8kxkTaTo2ObT/yCWaQNXU3ZORghscjbJV934dt20Mt3RVC8MKLLyJfKOCrL7+EZdt49dVXR0odkTS+B4jTMKqqot1uZ5GDw4wwDEEAqN0pBUWBqmm9B2uxKkuJO3fu4KMPP8T8/DzeevttGLqOuqoChCAMQylqIoqCxcVFLC4u4vnnn4fjOLh37x7ubm7iMrdmNU0Ty8vLWFlZwbFjx6YrskvzgDMG9xGUL3aD8Os3SHNw6+bNQ9uBEUg0ekmuzgdcfzmxjQg2blrhEGDsEswuY7Huqyp/58+ydKXkVTBbDx/iNx98gHw+j3ffffdgDYY4ZKdGxgZ2arRt+9GIEZMQZD3FSxmvnpll5Yyu68ibJlq2DYtHVgYeE/9+9uxZFPJ5fPTb38LzPLz11lupF0B9Tba6nmlVVaEoChzbhuu6oJQeqSqix4YcAICS+PBEjsowjMmd6hjD1atX8cUXX+DEiRP43quvSvYvGOkgQUo+n8fpU6dw6tQp0CjC1s4O7m1u4v69e7hx4wYIIVhYWJBRBaHUHRspyEEQBIjCEOSAyxe7oRLeNKgPOYgYw61D1IGxlyUyQScZEHnRWQkSj5oBEoC9+3GKx97dfCreDZP7u3XrFn77299icWkJb7/5pvQ56UjXHBBEp8ZgQKdGy3GwesBRjV5Is3JmlM48rSCet3yhgDafgMMwHOw2mXgO1554Aj/I5fCb3/wGP//5z/HOD36QTuzJWNxLofsadI2rSSLQajbTntahwWNFDmT3OQChIAf9bqS0gwNj+OKLL3D16lWcO3cOz3XlsFSx8h2iVpVmSaqKY0tLOLa4CLzwAtqWhfsPHuDevXv45ptv8NVXX6GQz2N5ZQXLy8s4trSU2npVIA0ZcnkY7KDLF7uhDIkcPIoOjIP6F/S6VkRRwLo+/1lc07EFiYcBB1lpwRi+vXgRF7/9FidPncIrL78cm5T1IczJY5p2+alAmk6NjmU9skqFJNJ8QskU1yzIKsPe/W4YBnRdBwsC2I6DygA/iu5Pb2FxEb/zwx/ivV//Gj//27/FO9//PqopCJiCHpqaHveG+BztdnvoNg8bHh9yIG5W8JQC4kFU07TeE2WKGzqKInz00Ue4e+cOXn75ZZw5c2bfa1RFgUIIwkHkoNeAw1loqVhE6fRpPHX6NMIowtbWFu7dv4979+5hfX0dCk9RrCwvY3llBeVSaehxDzuziIujHnVKAdhj3/2ERrdu3UKlVptJB0YG9CaJEw52sypUPcqRg1lNuh374CVun372GW5ubODCs8/i/DPP9P48UxACkZ6QupAJzmFYp0bXdUEZe+SaAwCxMJGQgcJEGkVxGeMMKpySxECgVCxid3cXtuOgVCz2DN/3e57L5TJ+9KMf4b3338ff/eIXePPNN7G8vJzqODq21GPbghxYR7AB02NHDoDOlMK48H0f7733HuqNBt56+22s9VE3K6oarwgGkIO+j1hXmEpTVawsL2NleRl48UW02v9/9v4sRo6rzQ5F144x56wpswZWkVUcJZKSSImiRImaus+5bxcHMAy/3Ibvm417APtcuO02YD/42oD7oW2g/WCgYcBvvn7thzbg66n/X/r/FklJpEiK8zwUycqsuXKMed+H2DsqMiqHyMzIrCLFJRCkqjIjIiN37L32961vfRUUCwUUikXcvHULv9y4gWQq5WoVJicxkctBarWLbBMZ4e2rZUUZaI13GAg+l0SH0oaFz7QsvHr5Eu8cP973eZxWYf7XaKF1hrn7jhiD8GjgaQV+TNOycOHiRaytreHMxx/37Ynh7zoYODF/QVfHk2UZhmHAsCzEAuORexzshiaiGQgh7pza4vuymXV8lDl2vrg3IyUx1oTJtm1out40wiIAcFpcrxqL4csvvsCPP/yA7y9cwEenT3dMVe6oCmpybJ5ervn6QLwu+NWQgyhTCtVqFd9//z0Mw8CXX3yBsTZdt0RGDpq5eHnnane+NvqAdCqF9OHDOHz4MCzLwvLKiksWXr3C40ePIAgC8vk8JqemMDU5iSTbdbQTvFHH2e6jsAeaFxFePuU4cGwbgu87e/nqFaweOjDSJvd7mAvqIHbJ/p3U6yR64vCXL0YJ/r1Wq1VcuHAB1VoN5z/7DBO5XMRn8sGna/CbnXX63tt1aqzXaqDA3ogcAB3LGvl4jGpzQbFdxdMMgiAgkUigXK2i1mP/CVGS8Olnn+H6tWu48vPPqNXreOedd9pacQerkILzCo+c6LruWdC/LvjVkAMeOeBNlgRRbJ2rb7NQbG5s4PsLFyBLEr7++mukOnRIk0QRYItbM9AO59txPS0eDkmSMDM9jZnpaVAA5XIZhUIBhUIBv1y/juuUIp1KuURhetolNE3Oq5smHMeBKIrD813oAB4tCE5EL1++xPj4eMcOjDuiAru8sx5EeZd/5/1aRg7Y31FfOyEE6+vruHDhAkRBwDcD6JHQ5uQAGkWQvEcL33nTwOsVWYZt2zBMs2F+qtVqkERx10qKm6FdWaNt227PmogWwzCdDROJBMqVCnTTbC5MDCHEJoTg1KlTSCQSuHXnDmq1Gk6fPt0yTdHwLLeJHDiUolwqYWx8vOPn2Cv41ZADHjkwTROiILR/yFrs5AtLS/jhxx+RzWZx7ty5toYlHDyt0FRz0MsOMswAh1v/m0mncfTIEZiWhWUmalx88QIPHz50tQq5nFsBMTnpua5pmgYK7ImoAYcgiiCmCce2Afa9WbaN5UKhaUohGBnYS4vloOq+HZ+m5rXEAKoVAPeZvfTDD8hmMjh37pzXcG1X4Es3+Hec/siCJEmuRikQaazV625KYQ+NZU5yghER6jiRlTE6lLoNnEJ8blmWEYvFoDHL4mw229tJCcHRY8cQj8fx888/Q9M0nD17dseaQdCYWmhaqcSJIKXY2tx8Sw72GhzHAWEs3WJ1xP5dccPQbkMMLl68iOmZGZw5c6Z9B0cfOHulbVTIg4YsSdg3M4N9MzOgALa2trC0tIRXS0u4dvUqKKXIZLPI5XJIplLIZjJ96TGiBp9gbF9qaHV1FaZlIZ/P77nIQBB+k55BwRMjvkZhSz8GoTl49PAhrl2/jqmpKXx85gwEUQy1Ax02/IurJEkAIXAcBzalXoO4OicHewzNyIHNFvN+olhcX9BtyW8ikYCuaahpGtLpdF/Pw9z+/YjF4/jh0iVc+P57nP/ii53zt2+z1uo6RUGA7TjYes3KGX8V5ICnFDgbF0Sx9eLe5Asul0r48ccfMT09jbNnz3alBhdYbg6EwLashsHVc+Y5RPSg5VsBjGSzyGazOHL0KEzDQHF5GcViEc+ePkVd16HIMqampzHF9Aq7HUXgE6TjOF75UGFpCfFEwuvtvtfBr3BQqvw3hhxEcSzHwY0bN/Dw0SMcPXIE7x4/3nQR24vgDXscw4BlGBAUBYIgoFKtYnQPeBwEQbCzNNq2bVD0rjfopC9ohxjrAWPZNuqa5umsekUul8Pn58/jd999h2vXruHDDz9smG8I3JJG//PdrH0zAFRes3LGXwc5YCF9yzQhdsrbBSIHhmHgwsWLSCQSOHPmTE9lYqIggLByRm8/3u9E1aMi2ns7e6+sKJidncXMzAzm5+extbWFWq2GleVlXPn5ZwDA6OgoJicnMTk5idHR0aEsQF5qgCmiKbbJHaUUrwoFTE1NvRbEwI9BLVDejvg1ux8eIoocWJaFyz/9hKVCAac++AAHDx2C7Rs3rwNkSXINkZirqu04qJRKrvCWbttFD9uoqSkI2WGK5PShN+ANvnqFIAhIMu1BtVZrIAe9Hnd0dBQffvghLl+5gkwmgyNHjjT8nvgMkZp9G3y+rAa6R+51/CrIAbVtOHAnjqZCO79gyP9jx8GPP/wA0zRx/ptvujYb4uCKVX85Y2TTVB9RBAiC915N0wC4piAL6TRw4gR0TUOhWESxWMSjR49w9+5dKLLsihqZrXOkfe6pr+ufr0yK33fbcUApRbVSQaVaxXsnT0Z37kGjmaNahODk4LWNHLC/+yEHmqZ5zZPOffqp1zyJtDE42ouQZBmEuf3x8W45DrJMSNmgV2B/7+an4xsN/rzavFVzF5GDfqIFQSSTSZQrFViWBcMwIkmRzu3fj1KphJs3byKTyTT4IPgNkdqlD23bhlav725XzS7wqyAHcBzvQWuaUuALbGBiuv7LL1hdXcXnn3/eV3hKZGkFT2TUqXyxW/QYRfCMTCiFwcoX/Yu9Got5zaIcx8HGxoZXAbG4uAhCCEZHRlxR4/S02yyqy8/kiXmC1+87jsCMpBym2ygUCiAAcvl8V+fabQzKNpkfG/j1GiCVSyV8//33cCjFl1991dA8iYe9aZu6/L0EURAgsgon07JQYrnqTBOBXVDYyMPcQwWPHrBrcXhaIQxRpRQO8zGJCqIout0a63VUazWPHPQ7yo6fOIHS1hZ++PFHfPP110hzsuZ7TSuvFH5vqpXKW3KwV0ApBWzbXZgJaZ8H8y3YT588waNHj/Dh6dPI9VkTLTIFcoMR0iAmqR5Jgm4YsB0HQpvyRUEQMD4+jvHxcZw4cQL1eh3LzKnx/oMHuH3nznazqMlJ5PL5lozdr+4NC1EUPWvZQqGAXA+20bsJvkANKg3yOhsgtSKFYbGyvIxLP/yARDyOzz77bGdzon6ia7sESZJgWhYsy8JWqQRVljtG6XgXRMBXATHg6+QQCIFNqUcMgPZRLL4ZiCpaEEQimURN0yJteEQIwceffIJvf/tbXLx0CV9/9dV2b54WYyxYRVQulzE+SI+NCPH6zK49gnva89BXywXJ9/PV1VVcu3YNhw4exMLCQt/XIAhCQznjwB9YfyQkxIOnMUfEeCwWenGJx+M4MD+PA6xZFG9BvVwsNjSL4mSB73p63SWKkgRiWdANAysrKzhx4kRPx9k1kBad3CICfY3TCs3K+sLi+dOn+PnqVeQmJnDW1zyp6TleI+IkSxJ0QtzIwdYW0l2W5TUtlYz0CgPgUQs+DttUKvAoziCvJ6aqkCUJhmmiWquFspUPA0mScO7cOfz222/x008/4dxnn3mftdncxjeEAtOd1V4jG+U3nhyA1dvykBsobSgRAvsZAIB9eZcuXcL4+Djee//9SC5BYl4Hjm0PbwcTLO1rcl4CV6RpmSYIEMq3oRkEUUQul3MjLO+9h1qthqWlJRSXl3Hn9m3cuHED8XjctX6emkIun+96188jPqvLy7AcB1NTUz1d627By8sOCIMoBRwWerl2Sinu3r2LO3fuYP7AAZw+dcpt7/2GQJIkd8GxbWxubYXy+m+FoMXvoHQKAivZI0CDk6l3HdhOrQ0DyUQC5tYW6rWamwKI6LzJVAqfnD2L77//Hjdv3sT7773XspmdZdsgPGJN6WvVgOnNJwe27XUIkyQJgiC4VQu+hZCyScmyLFy8cAGSJOHsJ59E5u7ldWYcMFtuCj7hNkk5EAB1FjWIsZKpfkEpdVtQLyxgYWEBjuO4zaKWllAsFvH06VMQUcTExAQm83m3BXUq1XFXx7+L5ZUVpBOJ4bncRYhBffeOb1y9lpED9ndYakBtG1d+/hnPFxdx4vhxHD12rC2xeB0JE1hJo2FZqFSrOBJVY7FmqYcIoyp8p+yfO/n5hu0xEY/HUSqVYDkO9HodSoQl2bl8Hu+//z5+uXED2XTa7cPQZI61LAuUpWwpEK6t9B7B3r/CPkGZJz8AKCxnZ1pW4y6ZUsBxcPnyZVSrVXz19dc976KbQWS7ANOydr/8yBdFsB3H7TNBKdR+HhxeZdCEmfP+DnkmHqxUqygWCijyFtQ3biCRTGKKtaDO5XJNdSFcRLqysoJ9MzO9X+sbCL9HwOu4EHqLVQhiYxoGLv3wA9bX1vBxF82TyICrRQYBWZZRX1sDAXp3+2uDyKseWGjd8TkjUgyfFHCIooh4PI5qvY6KpmEsYr+WgwcPYqtUws9XryKVTmN8fLzhs3ILaUKIF6nm1Sdh2kLvNt54cgDb9nL9qqLAsixYptn4Gkpx+84dvHr5EufOnUM24va/oq+UcVBq9V7ArZIlWe6JyfpdzMIilUwidegQDh06BNu2sbKygiITNj5+9MhNUUxMuGRhagpJ1ruCCALq9TrqmoZ8HyHW3cSgKxX2yrjqGiHHT7VSwYWLF2FoGj4/fx4TExORn2MvQZIkVFg3v1REOfNW8J5hlnbo9W5x7Ysoiq6j6S7f92QyiVq9Dq1eh5VKRbtjJwSnPvgAlXIZly5dwjfffONWIvDNl88MyvaRhrfkYA/AYXoDTg5kVXUVtY4Dy7a93eiLFy9w9+5dnDh5EtMtWi/3A5GV4oFFD3bdmpgtIrquuz3iu/Aq4CHIKEqPRFF0yyCnpvABa0FdYC2of7lxA/T6daRSKe8166urEAUBIwPYRQ0ag8yzvtaVCghHbjbW13Hx4kVIkoSvvvmm68Xydbw3giCgXqu5tsnDWmQDaYduzsorFbhnwV5IcCmKAlmWQQ0DtXodmYjTkUQQ8MnZs/jNt9/i4qVL+NJnsczXHUmWYes6APfeVF8T3cEbTQ64MyIP9UisE6NpGG7eRxSxubGBy5cvY25uDkcDzldRgjCCYO0FcgA3teJQ6ppCKUrnCZqnDgZVK04I0uk00uk0jhw5AtM0sbqygkKhgBcvX+Lhw4dwqNuY5vnz59h/4MDeaV8bAoPslsiJWpiw/J5Eh4Xv1cuXuPzTT8iOjODTTz/tLwX2mqFarSKVSsGyrJaVGINCsOKhrTaBbcJ42eBe8ttIJZPYYOQglUxGrstRYjF8du4cvvvuO1y5cgUff/wxAFdv4DgOJFGEzl9MKWosGrTX8WaTA+aoxzUHkii61qSGAdM0oaoqfr52DalMBqcDntlRQ5Zl1HUduq7viUXNNAwAgML0EECjkrjhZ8C2Y+GQHnpZljE9M4PpmRmAUqytr+O3334LRZJw684d3L5zB5lMBlOTk5icmsL42FhXjmzDBk8pDDKC0GlC5t+v33DKnxpqlibiP+cOmoauQ9c0L/zsPTM+8uP/OfGNmZalbS0MnCilePToEX755RfM7tuHjz76CGKPYeG9s1R1h1K5jKmpqR1dGocNv66FNv7CGyO2ZUGAGxHcS+nTGCvRdmwbmq4jMQATokw2i48++giXfvgBc3NznjcOr1TwP/uvSznjG00OqE9vwCsGZFl2yxktCy9fvsTa+jq++OKL0F0We4UiyxAJgc4W5d2GbhjbjohsR+ARAscBDaYOdllEqWkaqOPg1OnTEEURuq6jWCjg2fPnuP/gAWRJQn5y0quAeF1cyLoBZSkx/9+246BWr0PXNJiy7OU5dyz+fZ7bYDod3TBQZ0ShV3hlxWzM6bruRvMUxf0d29ndvn0bT58+xZEjR3Dy5Mk9s9gMC7quw9B1pNJpOJTuWldXPzgRINieJzh4NZYgihD2kGW1IAhIJBKoVKuo1WoDIQcAMDMzg3w+j5u3buH8+fOunivwfVH2PdZqtT2xSWyHN5ocgDnqAds+34IgQJAkWJaFm7duuXX33QibegBl1QBEEKDreuc3DBiWZcFh9beKLLvNTvgv+cPP6pX3inlMoVBAOpNBPB6H7TiYHhvD7OwsKKXY3NxEkdk6/3z1KgBgZGTEM2AaHRvb9RK/dhOlf8H3/k2pW2njIwKtjmEaBiy2cNghtSDe4uz9wBcJCEYFAK9ZmSTLUGS5wY3Pu65gBKLFuYPRC9uy3HpwZnJlWxZu3b6NtbU1HDt2DPv27cPW1pZrNsNC1oIgeP/2/8xPchvuMaV9Ce12A6VSCRTASCYDAjcVuKvkwFeVFCw/5YsexbbGyt4j5ACARw50nlIeRCkhIThx4gS+/e1vsbi4iPzUlBfpCo69arn8lhzsKnxljP6HSpYkLD5/jnKphE8++WSw9qrsuNxm07YsmKbZvjPkgGEYBijgWSVTZrbC4Z9aG9zVfIrmoYJSFAoFzM3NQRTFhl0UIQSjo6MYHR3FO+++C13Xsby8jEKhgCePH+PevXtusyiWfpjM54eas+aLvsHMpnjFip8IdDvyvAWRua7ZLM+biMe99tpBjYM/zN/LDpyT2ngshgSrIAkDP3Hg/+/vp0HBCLuuu9oXx8HVa9dQq9XwwQcfYHx83Hu9Q6nrW9LhnISTBx+J4OfnP38dsLW1BQFuyFqr190qqygbnXUByshq8Nn3W6FzQaLAorR7JbVAWMRYVVXouo5qtTqw0tDR0VFMz8zg4aNHGJ+YgMSjFGyN4c+61mf0bRh4s8kBSx8AjeEdQgiePHniNQsaZPiLH1kUBMiyDNOyoOv67pID0wSlFJIsu73IQyxQfKe5G3uBza0t1Ot1TE5OQhRFWJbVcoesqirm5uYwNzcHx3GwubGBAiuVXLx8GQAwNjrqdpVkLaijmMD4gm8z0y2bXaMX/mekoNVY44u2ENgNez/zLXZBOI4DSxA8ZfZegl+TADTP/ZuiCEeWYRgGrly+DArgqy+/9Mq9+MLUEE3h/w6kWfjrGzqgsvvusPfy+ykKAkQWAudEcy+hVCohnclAkWWXHDBDnaEJT32RAgBtNwU8akDg+rqAEda9kFrg15BMJKDrOmqahnQ6HXk0kafL3nnnHfz222/x8sULjARt3n1jdK/jzScHvrpbjqfPnsEwDBw8eBC2bQ8t5KwoCuq6Ds0wMNiq5dawWBMqCjeCAnQXavWHEYcVQSgUCpAkCePj494O1g4h0BIEAWPj4xgbH8fx48ehaZprwFQs4gFrFqWqqpd+yOfznlFWK3QiAa0g8TwsXKK4Y3fbx7183asVHEqxvrGBmzduIJVM4txnn7nlewyEEBBR7FgaR6lbV+8EiARl3Q1N2waYgtxxHARH0F4jDVtbW8hms+51SBIcSgdfteCP8HTxNsuyQMDaq7NnQRRFmKa5q6TL/0zGYjG3YoxSGIbhRdmiAv+UqqJgZnoaT58+xdEjRyCzqLEfDU349ijeWHLgOI4rkGGhLU4ADMPAg/v3sX//fsRUFXVW3jIMHqeqKsRyGcYuhZQotr0NJEnyFhOeZ+6Gzfof+EHfu6VCAfnJSW+yBnp7uGKx2HazKMfB+vq6Z+v8/PlzEEIwNjbmkYV0Ou0SgJAkgI8zkU3mou96gW1iETVe53bNAPDy5UvcuX0b4xMT+PTTT3uOfvBxLAoCGjLzlEJl35tl27BZyZ1j27DYd+r/sydIA6UolUputQ5cIm+ZJsxBkQNOCgIiw7CwuN6A59i5oJlFwaJsydwN/FUChBCosRjseh36AMgB4JIk07KwsLCAFy9e4P6DB26TOH96Fm8jB7uOZnqDe/fuwaEUx0+cgKFpblmjogxEoBL8+hVFcUWJhjHU8CDXCziUwtB1VyAZnID70F3ssF6NMKpgGAbWV1fx4UcfAYD3PfmJXy8QBAETExOYmJjAyffeQ6VSwaulJSwXCrh79y5u3rqFmKJgjLWpHh0b887digS0igBwQjGopeR1dUiklOLO7du4e+8eZmZm8OGpU4NJiwS0F82edZ6K6IU0SKIISRQ9m/QoUKlWYdu259bKGzFZUVqw+7QfjuM0lJ12dxg3okHZpoODEAKBkwRKt0nCEMdpsHyYbwgHIQwnhEBjx00lkzh8+DAePnyIQwcPbj/7XIT7NnKwu/Acqhg5qNdqePjoEY4dOYJEPA5CiGvJW68jmUpFv/MKLLayLLsRDEphBPs7DAD+HCzgkiXLtkGAnUZMEXx2v/I9KqJQLBZBAc8y2VuAmQCql7p3vhBYluX9cSj1yIJj29jc3MTGxgbW1tawtLQEgRCMjo9jenISU9PTyKTTXS8EPH8b5SLeoBx/jciBw5onLS4u4vCRI5ibnW3ayS8KhCFPfZEGX4pLEgRIkgRRkrwFvReUy2VQwGt1LoqiWwHgOLCYsU5P8FWKOL6x2M/Y4XMKYYTZD69qgWybKA3a76MdVN5fxzQjr1owDMMbK2o8jiNHjuDJ06e4c/cujr3zDoDABmqP440mB1xvwMsYb9+5A0mScIQ5IcZUFYauw7JtNwcVtRI4sBsXmGpWN01omjYwctDMzAZgQkS45WjBqAUJTBb9oilR6AGFQgHZbBZxXwiQVyxYIckBDyf7yUDw3nCzEkmSIIkiRkdHcejQIRBCUKlUsFwsolAs4s7du7h1+zYS8bhn6zyRy7WdZPyLU9QLuOP7HK8LOTANAxcvXcLG+jrOnj2LdCrlidkGjW4XpjCkwbJtL+1k8WZmzM9EZGRBkiQvuhQGW1tbUGS5ofpEkiT3HKbZEzmgPCUWASHwo5no20OTc/Ao2jCWx+B3LYoiFFmGbhjQdB2piMgBpRQaqwLjHW5VRcGxo0dx69YtzO3f727IeOTgNWgC9uaSA59iWRRFlEolPHv6FO998AEkFrokhCAWi6FWq0HTNCiKEl30oMUEpKqqa1ozgLBWMFIQhMGMj5RmoVsWKh8Eo/ff0W6OTh0HhUIB8/PzDT+XmE9Fq9AcD3OajAjwSoGGa2KTrfenTQ45lUohlUrh4KFDsC0LK6urrq9CsYjHT55AIAQTuRymJicxNTXVtp105LumARKPQaBaqeDChQswdB3nz5/H+MQENjc3AQyw3bSfQCGaRclPGjjF50JVy7Jc7wauVzEMz/xM4GSBpSFatYUvlctIp9MNz47ENhbduCXuKEEcwBgxmcC5GYniVU7B+dD7v0GWkQNN0xiKosAwTRiGAXRRltsOhmm63jGUelFZArdz46OHD/Hg/n2cOHly+3O/JQe7B2rbDZqDW7dvI55I4ODCQkOoW1FVaLoOy7Kga1qDSrqv87cY9JyARE0OOhnP2Cz8SYDWEYsBP6hAd0RhY3MTuq5jKtAMyxMlsgeMh3a9P01IgxAgA70KykRJ2m4WBaBSLnvNom7evIlfmOKe+ypMjI+3NOaJAn5b272OjbU1XLh4EbKieM2ThuHC2TDOBjjGuQaB6yY4SbX5uGRpCMMwYPjeI4miF7XiY3trYwMTzIKXQ5IkEKB1SaNPQzBoQuCdkhGioN7AD4GQhghX4wHcCOcgNiYEaCqujMfjqDJDJN4Loh84juMJveOq2lC+KwoC3j1+HNeuXcP+/fuhsu/0beRgF2Eyu1dRFLG+vo5XL1/i448/3jEQCIBEPI5yuQxd06Coaks23xVaRQ6YRSzPT/XreOZNBB3AjY/8VQpBdNuFrV90IgrFQgGKLGM00N5UIASmaaKuaXBYSWEQnAzInAwMKJ+dSqdxOJ3G4SNHYFkWVpaXUSgWsbS0hEePH7vCx/FxTDJCEbVCmlc/7PUyxpcvXuDK5csYGRnBp+fOeSWjweY+gwDlYrshg5vv+MkCd4PkJNZxHBiOA7D5ikeAypUKFg4ebDgejzo4rDTTH6Zu8CNwDzSUz8j1BpwYNUOne8+jaY7jePNhJEShBRGUZdk7p2GafaeTDcMAKIVIiFceDmzPb/v378eD+/ddY6TxcQBvqxV2FTwPJogi7t++jWw2i9nZ2aavlWUZkizDZFqA5ABtLb1dK7NS7tVCs1MKIQhufNSpI+RuuZo1Iwovl5aQn5qCIAhedMBgIdpavQ7qOJ7Ik0+csi8yMGxIkuQ1i6KsFK3w6hWWikX8cv06rl27hlQqhXw+7zaLGh/vm4ju9TJGSikePniAGzdvYnZ2Fmc++qihQdbAKy0C43k3Uy+EEEhsrgEAcC0MT0WwHXi5VALgjqdyuewRDFEUIckyDNP0XFZ3e5HhKY52mhtuxd3pWv3Rg7bRhrBoU3KsxmJwWHq3H3LA3U+p4yDORO7e6fn5ABw9ehTXrl/HVqmEWCz2NnKwmzA5OSAEK8Uijhw71nZiiMfjME0Thq5DVdW+GjF1GtKqqkJjgpheyEE7p71m4CImAjTXG/jgt5rdLRC4kZ/NjQ3Mzs2hXC67eU3fdUmSBIEQxFQViURi13snBEEIQTabRTqTweGjR2GaJpZXVlBYWsLi4iIePHgASZKQZ42iJicne0pp7eUyRuo4uH79Oh4/eYJjR4/i+IkTO65z0JUWvdTsDw2+VBdYAzTbcVAsFkGI28LccRxomgZN0xravnviwl1G0N+gFbrV2vBeGN36rzQco83vVEVxSxr7bISnaZqXUgkSJP/IG5+YgCiKWFtbw2Q+76W89zLeWHJgsTBdiS0s+Xy+7etlSXKFKoYBrV5HKtWHh2GHwawoCkSga91BqyqETuDtmUVR7NjWeDfLjAB3UjAMA0tLS6CUIh6LeR0BJVGEzBr/qKoKTdPahjP3BNi9lGUZ+2ZmMDM9jQ8++AClUglLS0soFIu4evUqKKXIZrOuAdP0NMZGR0N9LmePkgPLsvDjjz+iWCzi9OnTWFhYaPq6YZObvXWXAmAVM6XNTWSyWWSzWXfDwhprUduGTSl0TYPlOBBE0TVW2yUXR8oqNUBpx81UL9fHUyVCr3NSm/fEYjFga8ttWtZjSaNX+cRKF5vBP5+OjIxgdWUFePfdXd+AhcEbSw5sy4IIYH11FbIk7chbB0HhNpUxDcNVsppmx112S3QQPamKAoG1HQ4Lbg3by5DSeUohRPhs2LoDwI1s8PvOIz5r6+sQJQnpdBqqoriEyt88y3Gg813UHi7na3YveVQhm83inXfegWEYXrOop0+f4v79+5AVBZP5vEsWpqa8+uwdx9+DmgOtXseFCxdQqVbx2blzmJyaavna3Yh87DYBbgV+Tcurq9jHnRFZSsGrwGFaG+I4qLN+CwJLV/DUw7DupWVZEADX2rrD+CPorVKEYDvV6XShHen0HYtso0FZmrIXcqDrutfAjveTaHUdjuNgdHQUDx88cK3X30YOdgf+sHtxZQW5ycntQeWrVPCDwB3kaiwGTdNQr9ch92JiEmLSUVTVzakx5XI7HUC32oIgHEphMX8DJeQDMIyac5urtpuUZkmiiFqlgonxcYy06J7md0oEtheXoChr16lCkxLK4BhUFAWzs7NeC+qNjQ0Ui0UUi0VcuXIFADA6OupVQIyOjHiTMT/6XtEclDY3ceHiRQDA119+iUwnUj7oaosmz82wauw7wf9s8/Fbq9VQr9U84RqHX9xICEGlWnX1FNiOthmG4b5OklxtQ4SOjc0Q7NHSCf3YKHNvhCiJnaooME0Tuq53rTMzeYdVx4HSJh3Ir5dSirHxcdj37mFtbQ3JiEooB4k3lhwArkXl+toaTp06tf3LNg8LATNGYpUEdU1Doss8cKsSRj/8Zkg6a1Xb6nPwVEKv8KoUWF11GPQcxusAy7a9CEGw3FCSJCiy7JV6bmxt4dChQy2PxQ1luFe+39rYj90kCy3vYbsxSNz+DmNjY3iXtaAuFAooLi/j0ePHuHv3LhRF8XQKiUQCwh7pKLhcLOLSDz80bZ7UCruimRhCyW4zNCMD7uVs/3ttbQ0UwFiAHPjBhbeUEKSSSVfQaBieLodHPgngRRQGQRS43iCsPqvvs3cRPQgzf6mxGCrVKowuSxq5DoRS6kaB2+i0KLZTf8lEArFYDMViEfv27Qt1rt3EG00ONjY2XOvdDnoDDgIAgoBEPI5KterltLtSs4acdGRFgaBp0HQd6YBpTr/RAj8M0wRCVCk0IMLJk/dz0Bjh8kNmhEBWlAbVfqlchmkYGB8ba3tsXtbVLmfYliy0eM2g0c3uR1VVHDhwAAcOHHCbRW1suM2ilpfx/PlzgBBkMhlMT01h3759yGazu0IUnj59iqtXr2Iyn8fHZ8+G7pEwjGqF3YCf1LcjA0Gssl1lO/dUURTdhZI9TzIjCzHqGr+ZpgnLNOFQCpNVNgBuikLpU2zN4S8hDlsZ5PVu6OM7Cd7HVs9RKHLANiIWpTBD2tk7joNqrea2/iZke15tVRlBqRctEQhBPpfDyspKx/PsBbzx5CAZj4cO4fBdv6woiLOcXq1WgyAIvesPWkBVFAjYKUrkQywKYuBQCpNFDrq5/ih0B5ZtQ9N1t9ETPy5YhIBpCFqFwtfX1kApxejoaNtzSJLkirW6cIxrRha86wtoOvpdsKJelrhnwsT4OE4CqGsanj59itWVFTx8+BD37t1DLBbz0g/5fD7ycRsEpRS3b93Cvfv3sbCwgFMffNCd/oGP8wFpJpqSwehP4s0dzVJy3YyjtdVVTExMtH0Nb/rlNImaear5eHzbJdQwGoiCIIpQFcVLUfQC7m8gdikIjqREkYHv9oMuiGHTRoQQKKoKh1WDdCIHlFLUWQk1oRTxRKLB8Khd9ABw0yq5fB6Li4uo1WohrnB38UaSA8AdIBsbG8j79QYh3sO/yFgsBuo40HQdtUoFQjrdUbTSzZBXVBVEELwaWcJqfKMM53NiILHugaHR4zVQ6jaU0jXNExYC7gQSi8VC21Ovra8jk8123H3yHVA35CCIhrHhSzv4vwtvXHSZlhh0bjsei3lujalUCptMq1AoFPDs2TMIgoCxsTEvBZHJZCLdoTu2jStXrmDxxQucPHkSR44c6fr4g9Qc8O9wxzX1cQ+85zOoXYrgcxiGgc1SCQcD5kfNIIoiTOaN0Gpe8ohCLOam9HTds/mt1+ueZbwiyx2rmIKwQ/gbNEOU3zOPHHh6o+1fhJ7DeNWTEaKksa5pbj8NSpEMlk+3OZ/fuyGfy4HCbSi31/FGkgPO8CqVCo4fP97zcWLxuKukN01UqlWk0+n2pjVdLKqKLEMUBBDqNuyIqWrkeX5eAth1/3fSXec0h5VX6YbRYO6hyDJiqtp1G9611dUdgqxm4HlUmzW+idIFMbig+EmD/2ftSEOr+xeVqMrx3WtJFJHL5ZDL5XDy5ElUq1VP1Hjnzh3cvHkT8UTC6/+Q69AsqhMMXcelS5ewubGBT86exb4WBmMdP4Nv4hwEmpEVXj/f9Hn1RQH4/zclEwO43vX1dRDHCTX2RUmCwKJmrSpZ/JBEEVIigRgz7TGY3a+u69B13U3xqWroMcHFiN0+c4NIH3kljz1ssOKxGLa2trwIZKvPr+m6m6pxHCTi8a7MyzwCzJoxpVMpLC8vR2LdPEi8seSA53VyIfUGzUAIQTKRQKVSgWXbqFQqSKfTkU1kMjNDqtVqkXdodJgwKYwrYlOEYN+WZbmpAxahANxJXlVVt/66h4FvmCZKpRIOHz0a4hLdunBKw3do7BehSQMPnzbbuUaEdiWcyWQSBw8exMGDB2HbNlZXVz1h45MnT9wUxcSEVyqZSqVCX2e1UsH3Fy7ANAyc/+KLtuK5jp+hxfUPEkGR747FJCBiHRbW1tYgqyqSITxWuO6g25I4IghQVRWKoniOozz9YFqW101QZjbvzeAwv4VuxIjBa+i1aqHlMX1RBKeLY4ui6Io7mZ9EM3JgGIZHpmKx2M7XdJgrHZ/mAHDbzy+9egXbtt+Sg2GDUoqV5WWvRr7b9zaIXgQByWQS5UoFtm2jVq0imUzufHB62AmqioIqIajV6x19GLqFyYgBbxnbLVqFxLkamjer4pBYGajaRx4TcHdPFOgoRuSQWYdGM+QOalBoRRraObw16xTZDcKWMYqi6OoQJicBAJVq1SUKhQJu3bqFGzduIMmaRfGoQiuR2dbmJm7evAlFUfD111+HWsjafwj2KaJahP15/4CGhAbI2l7zOlhbW8PY2Fio0LsoCNs19LbddVrAXxrp2DZ0VgrpOA7qLAcvK4rnyeKHZ5ncY5WMAGBQVf69fKeqqsJgG52gY61lWduVCcyALYiOd8AXOQCAfC6HR48eYXV1FdOBpnJ7CW8kOXAcBysrK3inTSlcM/A62iAEUUQqlUK5VHJLhOr1HXWxYUoYG64RQCKRwObGhpejD1svHAY8h9ZT1ADYZsPsftis8xjvPga490tRFMS6CEd2wvraGhRFCS0i5eftR3cwMPD714RIevawPjT8jL2HoDWJ8HZfXU7QqWQShw8dwuFDh2DbNpZXVtwW1IUCHj9+DEEUkc/lPLLg/y6uXr2KsbExfPrpp6FMtTqBBnwqWr+wUexH/eF+/jvfMSjYM+nbRXrpBERbLx8FbNvG2toa3n333VCv51Ezm/VmUPqoQBBEEfF43C3jZjtor3sk200riuKl8Xh3116f+UFGibzvlaX6QlUtqKpX0uiHbduo1Wqg1HWAbLn56DJyMDExAUIIHj9+/JYcDBurq6swDCNU7m4HWnzRoigimUy6rT51HQIhvXnh8z+UQmR5PstxUK1WWxr+9AJe89wzOYBrCmUwQmAwIyUAXk+DyDpY+rC2sYGx8fHQE4hnhsQ63O2VMF3D4hUE03QEx1nDq3kZXJO3cxLh+AR3/vMR9u+G8LnvfP6FURBFV4cwOYkPPvgAlUrFjSoUi7hx4wauX7/uWomzY+cmJnDus8+a71T5NQRV+wHhmD+vz1Mv3j0LHK/Zou99Hv/9bHKfdquMsRdsbW3BdhyMd6hU8EMURQg9pBZagaccVFWFaVkwWHSQ/xEEAYqiwLQsOOgtpeA/V9SpBWBbw8LHVphW0CozpbMdB7phQFUUOI6DWr0OwK0OadVNlQKA47SMHjg+8svHsSRJGBsbw5NHj/D55593+xGHhjeSHKysrIAAyPaw2LZTmMuKgjilrouZprmLu6/DWidwUuB/ZSIeh6ZpqNZqkZED7txFEL4GOQiDdT7kNdKAO6hjqgqlz9RBKziUYm11FUdD6A04BEGAJIqgcKMH/ZChKNFpNPRTyRDUOXjfBBtbflLg/x387/OF1v3fZCKVwqHDh3H48GGYloXlQgG3bt/Gxvo6HEqxvLKCS5cuYWpyEpPT0x5BFnzH884TPLd/7LOfcVObpuOpy+qQIF4fauCmFERBwEgX6UVJFKEDOwzFogD3TnBsG7ppwtR1d8GsVlGr190oQh8ppYFV8gR0OA6rBGs3PxPi+hVobCOkyLLX9RXAjm6LfnTaivDngaeBOEZHR7G8uhryQ+0O3khy4LCFcUepScgFrWn5E4Oqqp5DVrVSAUmltluwtjsmdhIDAEgkk9jc3Iw0tWD6yoy6XcQty0KtVnPD9GzhiDp10AqlchmmaWIspN6AQ5Ikr+3tXiEHHdFlGqrZ+/1phVZHanmGZos4fMSDvebps2f4tvodriq/IG7H8f+c/iMYdRPXrl8HvX4dmXQaU9PTmJycxPjYWFuPg+C18OvfofNhr+17AWmzMx2ezDAcVtfWMDIy0pXYWZIkV5TImv8Mor+GIIqIiyJiqgrTMFCuVAC4RL5SqbiRhjbixVYYxOaiWaqIR+g6pZHUWAyarkPTNEiiCIe1z04mEu2/E0FoO868yEHguyHAQCInUeKNJAfeIAiEHsOgle7Aj3g87uXkqrUaUqlU2/B6K2IAYCCpBZuVGXWzmNuWhXqg3jcWi3l9IIaB9dVVEEI6mh8FIckyEBBI7jo6LPzBha8hnx74d6vjD9JdkDdPell9hcvkKmxqQyc6vjcu4V99+f9xW1AvL6NYKOAZaxYlSZLbLIr5KrQKxW5/hMbn1HMG5b9v8T6uHfCTiIb3+RaDlvdmiFUInUBZxGz/gQNdvY8Q4pohEQLLcSAPMKXGDYMUll4UGCHlRmdqLNZVRHEQd7+duRIvdWxVycCF67VazTWHAnZ6GfRxTWJQsLzHNC/N8EaSA46eF7UQu7pEIuFZ95bL5ZYeCBSMPba5lqhTCybb9YchB5Tl1vxOjYqiIBGPQ2BlgsNiuOsbG8hms11HKDxRImP7e6HPQMP4CZbG+cP//re0+HfrUzDdQMSfd8vXPGnq+DRwc/t3L2qLAFgL6n37XI94SrG5uYlCsYhioYCff/4ZgNuidjKfx9TUFEbHxnZ8L2GrLYLgUY1WJKKhKsH3LPuJBBer7YWxwnVMvWikREmCyZwSoxQ0NwPvJiiKIjLptFfK7FDqbix0HbFYLLSvSeQLZIdj8RRDs/mMV23Ytg1d0zA6MtIxJdtJbwCgZdfUvTDuOuGNJAd8EPT6BYQJZxLiNj0pl8suQSiVkEgmG0pdKBhz7HAdUaYWHEo9gVK741BK3e6TmuY9VJIsIxGPNyzOhLj1+sMYzGtra8jlcl2/j1u4Oky5PehJshX8O3kv7x+MGAW1ABGcL8pdcLFQwI8//ohUKoVzn32GqxtXG8/Z7MkgBCOjoxgZHXVbUOs6isvLKBaLePLkCe7dvw9Flt2IAmtDrbD0nPv2aMdWQ6liE5GjJ9xkuejdJgmrq6uglIYu3/VDFEW3NNCygAGX8pq+Zk5cnCjLMnTDgK7rsClFtV6HZBiuH0CHxTVKchD2WM2IAWXkxktBCEIogkPQ+Tl2fHNCA0IIJXcbbyQ5aLA47eMYnSYMIghIp9MoVyqwTBPVSgVOPO5aL6NzxIAjytQCdy4TBKFpDpJS1xWtrmnegyKyUqZW+fowit9+oRsGyqUSjh071tP7ZUmCzSI5QyEHPiU930H4w9qdjFiiuJtOhEQDAJ48eYJr165hanISH5892zSCE+a6FVXF3Nwc5ubmQCnF5sYGllgFxOKiG3kYHR1FLpdDJpOJ3OOjHWiz6AX7DoP3cVikYW1tDelMpmsnUYBVDDDdwaBhspSCHNg8cJGyYRjQDcM1jKtW3WZQsVjLlGukVt5dzk98A+g4jquxsm2XFPAui2GOESLC7JUxNtMcvCUHw4e3g+tRqR9Gd7D9YoJ0KuWG5jUNtXodlm0jFot1JRCKKrXgFyMGYTA3Rr9IJhGPdzYPEgRgAIpoP7j5UbdiRA5JkkC6bMIUBlzNzxeP4CTU0uAIHRZtvquNYILsW4hGKW7euoUHrHnSB77mSQIRAi/tchImBKNjYxgdG8Px48eh67rnqfDo8WPYlgWVRRWmpqeRz+W6t/vuFYHJfccn478PEoqIScPa2lpvZddgmwBGbnoxQwoL29eFsRmJ4eV+sqJA1zQY3HWxUoEqy265YHCcRrQ4+qtzunkP9zHgnyuTTmNzayuy0lD3sgaT+hsG3mhy0Be6UZMTgkQiAVEU3fyhpsGybaQSidAEJarUgsX8DfzkoKECgV0vNz0JNckNIfS6trYGVVV3OJSFRWRmSIGSP782IOyoCpYHNoOXD+8DUQgSefOkFy9e4OR77+HI4cMN1xUsJmwuqw0PVVWx/8AB7D9wAPVaDcvLy9jY3MT62hqeLy6CABgbH3dLJaemkM1kerpPYa4y2IWz6XE6nbuJF0M30HUd5XK5q/JdPwghkLgZkmX1ZYbUDgZPKXSogBIFAYlEAoptQ9d1mJYF3TRhmOaOygZewtrvfN1LVYthmm6HReq2Xk4kEu51MHIQxjPFobRtKWND87Ym0de3kYNdQBRsrZcBxwd+tVqFZZooVypIplKhvAaiSC1QbC+OsiTBtizUNA1moAIh3mVUgxDiihMHKExcX1/HeBfmR0GIzMrVcZzumjCxnaFXTTLEB7bfUr3Q7oItYOg6Ll66hM3NTXzyySeY2bevyTUGjh3l/SEE2ZER5CcnEY/HUa/XUWTph7v37uHW7dteC+rpyUnkJifDi1VDjNUwYeFW1019/24WfQj7jaytr7t6gy7Mj4IQRREEiHTHG4RlGHDQPGrQDLzRE7cftliH22BlQxR+B928n2utDNbGWpZldz70ERYuNG9XFk0Icc3G2sCvNxAIge33YOjimncLbyw5EAjpO9za7W7ZZjv2VDqNKuvFUC6VkEwmQ4VK432mFmyfNwE39ODwVyD0hAFGDRxKsba2hnfeeafnY/Be9o5pwupEDnhEIAJtStPDh3xdv7umftodVyoVXLxwAYZh4Isvvmidzglygx7O1Qo0kI+Nx+OYX1jA/MICHGYnzJtFPXv2DISQ7WZRk5NIp9Mtx+VQ92QBnwnuUOldS5t5ZG1tDbF4vCe3VQ5OjAdhhgS4Gw7uytlLJVEqlXL1CEy0yCsb4nw+6ucZAEK/n1Lqpn1Zd8VYLOalVPmzKLEmTJZto+2MHYJYtiXvb0sZdwdR9IjvSndAG73yRSZUrFarMJlQMRaPI9ZhAkgmk9jqI7XAbU4Nv6thkwqEXkDg9oMYBEUobW3Bsqye864ckiTBNE23CRP7WYO9cIgwchQIE66OAt4utUvitra6iouXLkFVVXz9dfvmScHIgUOjix6122ULoohcPo9cPo/3ANSqVRSKRRQKBdy5fRs3b95EMh5HfmrKbRY1MTGUrpxhsCMV0YYsrK2uuuZRfZxv0GZIfiFir1EqXtlgmCZ0TYNNKSq1mvvzPo4bNvLgOA6qtZrnHhtPJBory9h3wueQjgLPEAu73UKM6D/nXsbeeJoiRmTlMWg/8LwFp8n5CCFIpVJuh7N6HfV6HbZtu01sWjwI/aQWKIBypYJKtQpVVd1ukolEpI6BwoDY7tr6OkiX1rHN4Ncd+NMEw34IQ5+t17A20PC+bibWFy9e4PLlyxhnzZM6RbSi1hz40U0pYyLQgnqNtaAuFApuC2pCkMvlPAOmUNqVYYnEBKHpXbNsG+sbGzhx4kRfh+dmSLYgRG6GRCn1LNT7FYoSQtx20JLkphhYkyceRejF6j3Ms21ZFqqsgRIA17SuybkopZAlCXV0tqQOoyviaR5+roamUK+BQPHNJQdRfAFhQkdovxjEYzEIgoB6terajzoOUslkS6FiL6kF27ZRqdW8ByAWj2Mkk4l8BzEoV6/1tTWMZrM994GgcHfrEjNt4iWNvR5vWOhndNJuyQGluH//Pm7duoXZuTl89OGHoVJMwWqFKOEXa3UDURSRn5xEfnIS77//PirVqlcBcfPGDVy/dg2JZBJTU1OYnJrCxPh407Gwa9MzS0OsrqzAsW1M5vPePXBsu6d5S+JmSBGX8nrGYuiv0ZIfAquSkiUJ9XodFqWoVKuIx2JdbWbCzEQ6s0R2AEiCgHgHO2Q+TtoJm8N8O5TShtbWO47xNq2wO+DNXKLYGXTSHYRqCaookAQBlWoVtmWhVKkglUw2DYN2m1rQdR3Vet0NKVKKRDyO0Wx2MMx0QGx3dX0dk/l8V+/xrHb53+znsizDMU2Yprlr5GAoKQX/uOvwvTiOg+vXruHp06d455133LbAoUt1A+eN8NNFYv/MInSpw4dx6PBh2JaF5WIRS4UCXr18iUcPH0KUJOQmJtxyyampxqhCP9GbPrFUKCCRTCKVTjcYWvVCFDwzpIh1B5ZhgAIDabYmyzJEUUStVoNumqhrGkzTdLUIIQhju8iuJzw0zabCw3bXBGynBJqfuPOYsX1RseA81GDStYfxRpKDWCwG27JgGEbf+axW7+U71LBHFiXJ0yHYzHI5kUhACXgM+FMLtWq1ZWdJh1JUq1VPX0AIQTKRcH3BBxiyiprxapqGSqWC48ePh3q9JyRscQ2yJLn11ZaF9s7+A0QX96dXtXZL57UALNPEDz/8gJWVFXz40Uc40KV/vxAo1hoEOYiyBlyUJEzNzGByehqgFKVy2WtB/csvv+D6tWtIZzKuqHFqyu3jsRshXkpRKBQwOTnZ8B02PF9sg+N1F2xzONFnhhRV2TFPKVCEr1LoFoIgIJlMQtA0t6rBtlFhGi2lwzlbeoxQt3Mub1vfTURCZOuFw3b+TbVaIVMZQOtoi85SKXsZbyQ5mJubw+ULF7C6soLU/Hxfx2o2efP61W4fP8EnVDQMAzUmWEzE4w1pBp5aqNRqTcmBYZqoVqveApGIx+HYNuq6PvDOiVHvtNbX1wFKMdam2ZK/XrgTZFkG2A5kt2xxKboIWfd6P0OQA61ex/fff49avY7PP/8cuS6jM82OHxU5aCiLHdR3RAgymQwymQyOHj3qNYsqFApYXFzEwwcPQATB0ypMTU52FA1HhXKlglq1iqnJyTaX37jD5NHQZkShwQzJcSKJmnluq+i+SqFbyLIMSZI8U6I6qyqIsbRsEK1GoWma0DQNtuOAd1Xs5toFttN3mOlTs3eGeb49vUGTcxO4VSrvf/hh6OvaDbyR5CCbzYIoClZXVzHfJznYUcfcZtcaFslkEqIoQqvXYRiGF0pTVRUgpGVqgcLtGqaxEkVREJBKJiFJErZKpR3mR4OAZxccEbZKJSiyvENA1g0h8EMURYiEwIG7ax6a2x5DL6Sx1/MArckBb55EAHz15ZfIRNDQy3/eyI4zAHEWbWFbvqNZ1NYWXr16haWlJVy7ehWUUmSzWS+qMNahBXU/KBYKLjEJSdga+nVs/9CtTmD3UGRmSA5rjtQvohIidgIhxLNoTyaT0HUdumHAtCzY1SriTaqtBLa753A4ofA1X0slkz11VZRE0Y0+miZiqrpT39NJh0a3+9v4Iwd8o6npOirVKhYWFrq+tmHijSQHIiuDWl5ZicZkI7AD7aa2thV49zJed1ur1WAYhuu02CS1YNk2qpUKLLbjijE3Qf75uLp2GH0FWnU26wWVchnpTAZA74QgCFlRYFPqEqshk4Nu0Wuaph05KBQK+MnXPKlT6+S21zcgqsMn9oHYyoY5JiEYGRlBdmQER48dg6HrblShWMRT1oJalmXkWVfJyclJqH3cxyAKxaJbftnDIt7wnfvIlSAIrhmS46DfJMAwUgp++Ftsx2IxN4pQr7vp01oNqqK4VVjss/JKF94rRmfaCMqs6xWfE2O3kCQJhLWAd3og+3wuFlhDOA7KiMVysQhRkt6Sg92AKIrYt28f7l67hlq93ldux687aFi8Igivi6KIdCoF3TCg1eted0dVVaHGYl5qQVFV1Op1dlqXEfvzcbx0TxCEgXmr+xFV9IAC2NraQiab7dioqBvIsgyNWbcOG13flx7HUCsvjyePH+Pa9euYmprCxx9/HIG/xYDSClGIEaO5EABus6jZuTnMzs0BlGJjY8PTKly5cgWA2ywqCq2CbVlYXVnBiZMn+758/7MoEAIIQiTPksWiBgIhkVUptEPwTkqShFQyCY1FT3XWNyWRSHjRHJ5CcBzHFR1KEmKJRE/RguC5+Yarl2+YeyS0In6rq6uYnJ52Tbz2MN5IciBJEmZmZnDl4kUsr6zgwP79fR2PC1S8KghEq0hXFQWKLKNer8PQdWi67jJ3y0K9UoEkSZAkCYosu+KdwKTkiV+GZQITwe6edy4slUpNbXv7gSxJIAAsx/H6zw8L3Rog9Wrhu8MAiVLcvHkTDx48wMFDh/D+e+9FEhLfoTmIygSpxzLGzoft8l62cK/jzaLePX4cuqahWCyiWCzi0aNHuHv3LhRF8TwVJvP5HcLidiguL8Ox7bZ6g14gsh2vzdIqBOhp5wv4UgpDiBoAaPo9CKxPg2Ga0Op12I6DSqUCVVVhsbA//7YT8Xhk18pF3c2MkMKkDXnkIDgfc+fMtY0NnD13LpJrHSTeSHLgdQhLJLCyvNw3OaCUggbLiiIuQyHEbf6hKorb4ZFFE3RdR7VSwczMDGItJiCT2SYPpVWxe7E9hcO9RkYsfMhzhINg0JIkwWF6jmGSg2EVJ/k9AmzLwpUrV/Dy5Uu89/77OHz4cGTn2VmtEA2ibjfN0e24JOhcrqzGYl6zKOo4WF9f96IKi8+fgxCC0dFRz1dhJJttG1UoFgpIpFJtnSl7gb/HQtDrpRstDHUcGLyB25DIAQFaRmMVWYbESh7rmoZSuQxZliFLkhtlDdtALiREZulssw2MF4kgIfopOI4XuWkWcanX66hr2p5PKQBvKDng4pzJqSm8KhT6V60PMfQpShIS8TjqmgZFVaEbxraPgao2fcC5qnhokQMgdFol6EPgvtX9FOVyGaB0IORAlmWYrBtcPzn3vQqu+TAMAz/+8AM2t7bw6aefYnpmJtoTBX0OIiLFg9Ic9KKF6eYKiCBgfGIC4xMTOHHyJOq1GorLyygWCrh//z5u374NNRbDJNMq5PP5Rt0LpSgUi5ienu76OjtBEASvvTp1nB1Ga01FjU1gWhYIO94wUgoc7Yid53jKFl/TsrzeCFGnpkRRhCAIcHinS/79sWtodzbL54q447oIwcrKCiRJ6l8oPwS8keQA2NYd/PLTT6hWKkj1sQBxv/JhmFZYloVqtQpFlpHP5SAAqGkaVtfXkTFNJJJJqD42z73CCVrnuAYBwioCWj4otLHdcTOUy2UIouhaSkcMRZZRI2T7/gxIdR5ELyMkqLwOdR7mc3Hjxg04to0vv/gCo62aJ/WBgdkn80V8SN9LW/SxuMQTCczPz2N+fh6ObXtRhUKhgOcsqjA+Pu5pFSilqNdqmJqaivADbENg5Y624zTojxp0Qh1SDsOqUgiimXjc4d0cWWdZWVGgxGKwbRu2baOuaaHMjbqFxMoZTUYOOCnolAbspDdYXlnB7Nzcnvc4AN5wcjA9PY2LmobllZWeyYFDtxv3DLpu3mT+BYAbBeCL5traGmr1OpLJJCrlMgxFcasaBMET3XXqsz4ICM2qFiiFg86hWgAolctIDkiUIwgCRCbOMq327VcjxZBcz9Y3NnDt2jWoqoovzp+PPETNsWNnH3EpY+SRAxZO7wa9kLOmxxFFTORymMjlcPK991CrVlFkzaLu3r2LW7duuWF6QmCx7qFRR/tEUQSxLDi2DbRJCVC4Cx1Pq3g/Z88LpXR4egOG4HxhGAY0TXPnXseBJMuu7wEhME0T9Xrd8zNJxOORzn+SJEG3rO3KA/8a0OZ9VpMSRg4Kt4/MF++/H9l1DhJvLDmQJAmyLCOVyWBldRUHDx7s6Th8keM9uQc19RumiRojBrIkeZN9OpNBqVxuCGfphuGVPdq7kVJg4LuRdqmDdqiUy8gOULEryzIsH/sfBnoikF2KEhcXF3H5yhWMZLM4e/bsQCIvvotr+L/INAdNj94neiAG7kVEa+zFkUgmsXDwIBYOHnQrFNbWcOXKFdiWhR9++AGCILgtqJkBUzKV6nuB4+WMYSsWeHSPz22maXpRSHHIUR3+yXlEwGalhNxFUZIkb67hosFareY1Vkp06JvQDSRZBmHp3J0X2ny8eFoPNI8cVMplGIbR81o0bLyx5IB/OTOzs3jx8iXOovuJaMdEzwdFxBOJruuos1JFhUUFOET2YNiOA8MwMJHLuc6KloVarYZave6V/QwdLHXQayvnrVJpoMIchZc0+lpYDxK9RpZCv4NS3Lt3D7dv38bU9DSOHTsGdQgGNX44iKZawet1H+UCNKBFPgqIkoSx0VFomoYP3n8f+XweBVYBcevmTdz45Rckk0kv/TCRy/WUJhSZU2Lb3gAB+FMOXiRyyFEDwCU0uq6jrmkA3DHCPQvQRI/Ao6u8FXOtWkWiSTVXL+Dibl7O6D83T8cEz2K30xvATSkosRj29ymQHxbefHIwM4NLDx+itLXVsk9BKzjNJntKPTOLKKAxT3HArbVONMlFZdJpVCsV1Ot1OLaNTCbjVjGw3gqarnuLxDDD594E38PbDV2HruueAdIgILGSRsdxYNn2UMVV3SDMSHIcB9euXcOzp0/xzrvvYmZ62n3fgFNJgzJB2jM+B0PE8vIyKKWYmppCPJHAoVQKhw4dgm3bWGEGTIVCAY8fP4bIUhRTjCwkQpJ/rjNwemjAZFmWa/wDDJx0+uGwjY9uGLBse9uzIJn0ohe8nDwIURSRTCRcguA4qFYqbrl3n6STrx82u56G/hdorj1oVcLIsbq6igPz88Obo/vEG08OcrkcNOap3g054Dk5P7i3eVR7kxrzNQBcx8RWqnpZlhGLx2HZNkqlEiYmJqCqKgRCvLJH27ZRLpchiqLbaGQAKl4ALinwW992WdfPUWapkkEbgUiSBIe5vQ2aHPQ6LgjQNiRusuZJq77mSZubmwAG5DDYcG3B4+/daoVeBcPDoieFQgGZdBrxgFW4KIqYmp7G1PQ0KKWo+JtF3biB69evI51OIz85iempKYyPj7c0O+M9FhxG3ruJzHDRn8r1S5QOVIhts0gBP69DKURBQExVG/QOjs+3oRlEUUQqmfT6zVSqVSQTib4E2jxtQR0Hpm1DCSz4DqXu2OUpVdq+RTOFqxM6/fHHPV/TsPHGkwNBEDA5M4PHT5/i8OHDoRZMfx59BwjZ6XnQA7hdMoDtvgptkE6nvQ6Go6OjEEURFEA8FvPer2sabNtGpVqFoGku4YiKJNDm1sbNRE1hUC6XQQCkBiSk41BkGQZr4RwfcEljr0TJfXPz76heq+HChQtu86Tz55HL5Xb46w8SwSk5CuGevz/JryZyQN0ujHNzc21fRghBOpNBOpPBkaNHYZkmVlZWUCgU8PLFC7cFtSgin897WgU/2eB9CgSWWpBCkgPqODANAw6wbehEGjtERtU3xLJt6L50H3UciJKEuKpCkqQdbacFUexYoioIApKpFGrVqhtBqNWQaNKToRtIkgTTNF3dQdDQKPDadi2aAWDxxQtYto2jR4/2fD3DxhtLDvyNSM6fP4+/+e//Hc+fPw/VsrbdQheFMLFaqXi5vUTACrkV4rEYZEmCZVnYKpUwNjq6bbbBvBHizHJZ03XYto1qrYZ6vY6YqrrlPj2G2jo1m/LKorqY6MuVCuKs4mKQ4DsAy7IGX9LYR7qpmWJ+c3MTFy9cACEEX3/1VUMPCv/7BolBdGX0JnpCov0+eiUuQyAom5ub0DSt6xJGSZYxPTOD6ZkZUEpRLpXc9MPSEq5duwZQikw2i6nJSUxOTWF8bAyCKIKYpptaCLk46myjIoli8x237/nmzZ66hWlZ0FnPAr4BkyUJqm8Rb/oNhvxeBUKQSCZRr9Vg2TZqTKTYK0GQJAkGS7U0vyzqRVjaRQ1sSnHn9m3Mz8+7Tb9eE7yx5ACARw7y+Tz2zc7i1u3bmJ2dbRtuCjMM+2mWU61WvYGUTCa7KhfKpNMwDAOlUgmj2azblhTbURJCCOKcJLAyIK781ep1qCyS0KyNaLNrBcJNBP6uamFRKpeRGaDegIMbuXA76kHm+/oKvwaIxVKhgJ9++AHpTAbnzp1rSDnR4PsGiEH4HAzEAIlHtnoUhA66TLlQKECSZYyPj/d8DEIIMtksMtms24LaMLC8vIxisYhnz57h/v37kGQZExMTyI6MhLZ1ppTCYI2L2moNeLSHE7qQJmimZcHQdbdjIvuZIstQFGXHYsq9Dvg3QQjpqleEQFyn2RrrVVOr1RCLx0NtwIIQBQGE0lD6jXYtmp8+fYpqpYKvvvqq62vYTbzx5ABwhTbvf/AB/sd/+294/Pgxjhw50vI9nSb4fhYATgwIIV5pTjdIJJOQtrZgGQZKlYqX89oxyRKCmKoipigwTBN1TYNlWdB0HTpzXuSdz5qBUuqa1JDw7XSbGZi0Q6lUwvSAjGCC4BEX0zT3rBjIb8v6+PFjXL9+HdOsedKOCWeIivxmX3+/C+lAxIhMD9T72wdLsgqFAvL5fKSREllRsG92FvtmZ0EpxebmJoqFApYKBSzdvo3bt25tt6CenMRoixbUpmkCjgOBkHAW7L5UQ6uxSCmFYZowWK8H7hGgqioURWkbMRSwPZf0Mt8SQjyXWe6HQNB9n4gwfXS4c2OzFs2Am0K5d+cOZvfvx+zsbFfn3238KsiBbdvIjIxgfn4ed+/cwfz8fNOBEnoY9pBn5ws0IQSpVKrnVq2pVArW5iZKpRIyTMzX8liEQFEUKIoCi5EE0zShGwZ0XYesKG66wncv/CHfbq8tbM7dZu2nh9WVTJZl1FmOc5A7xL6WbEIAx8GNGzfw8OFDHDp0CO+1aJ7UqiPjIEBIs0m8k4lse/Ax1q+iPEp0S267ga7rWFtfx4enTw/oDPD6O4yOjuLwkSPY2NjAyuoqSltbePL4Me7duwdFlrebRU1OelEF3R816ObZ4OlGQfBIguM4HilwsB155KQgTLTIawnfh4aHEOJpjEw293Fb5HAfbTsK1ekaODEItmgGgIcPH6Ku6zj+7rtQXwNXRD9+NeSAqCreffddPH/+HPfv38eJEyd2vL7rhi0hX2uaJnRWrhjvU0WbSqdRLpehm6bXoSzMgJdkGWlZhmVZLklgRkqmYUASRaixWN/lS2HTLZVKBQAGWsboh1fSSCls2x6cYVQfO3rbtnHphx+wtLSE999/H4faNE/iZxmGmK+ZRtwlWL0fcxBNl/pe2AfokbBcLAIAJiPuwtgKoiBAlmXk83k3SkopNtbXPV+FxcVFAMDY2BhyuRwymQxSqVRPoXd+3zgp0Fj1Fdf3cJ+Cnr5rQdi22e4BnCA4rDtrrVZDMpkM9dw0zKkdxoVlmkATIaJuGLh//z4OHTqEVDq9Z6OWrfCrIQcQBMTjcRw5fBgPHjzAoUOH+mvIE3IysR0HtVoNgNvdracH0AduimRsbqJcrUKNxboS9UmShHQq5WkRdE1zmb5locbKIFVF6W3hCXlPyuUyKB1Mw6VWkGV5u6RxF9wk20HXdVy8eBEbm5tu86ROTXmGqvTfeQ4HFP3s+f0dJSNDnwv7ICMHxWIRI9ksYkPaORK2gyW2Dce2XQOmiQmMTUzg+IkTbgvqQgGFYhGPHj+GaVlQJcmNKkxNYTKfDx2CdwLliJQ5GsZYC+VeRqgXlY2ArPEUQ4VVMdQ1ramXTKv3Au03jVxTAWBHSube/fuglOKdY8c6VqPtReytWTJiBMkBABw5cgRPHj/GnTt3cLrPMF8YT/ZatQpKqVuqE1EpXSadxtbWlrfz72UbJ4oiEokEYqoKXdfdCgfLQqVaRb1eh6ooUFS1K28AgnD3pFQuI6aqfROlbiD7SxoHNEn3Emwvl8v4/sIF2JaFL7/8EiMjI6HOA2AoKvtmYeB+694Hklbo95oiuowdx3UcFAoFzA+5Ra/nd+A4CD7BaiyG/fPzmJ2bw9bWFjZLJZS3trC8vIznz58DAMbHx70W1Nl0unGscZEh6w/Bex+IkoQkK0dsZVoUCqS3lvCtIAgCEvE4qrWa26lVkjrOPV76sUNlGk9ViqLYsOmo1et49OgRjh496qZU3pKDvQVODhxn2/RVVhQcPXYMN2/dwpEjR7w6+9ADuYvwY7VadVMahCAZMD7pByLrYy4S4kUlugKlXumhRxJiMeiswsGybdia5ubpJMklCh1ERI2Hb5/Xr/TZJbMXKLKMKlyBUEOP9gjR7VK9urqKS5cuIRaL4YsvvkAikQilzB6mu2DzM/Q3aUfeV6EffwmGKBcjP9bX16EbBqaGlFLg8Nsot1oGDdOEKAjIjY9jnln61ms1t1nU8rLXLCoWi2FychK5iQmMjI564kJ/OaIS8BTwl/l1C378KCFJEmKqCk3XodXrEAWhZXqXj4UwEQyDd7CUpIa14fadO5Bl2RO/v40c7DFwgYjD1LKA+8UfPHQIjx49wq3bt/HJ2bMAelRgtxEm+k0+UhHYeQaRTCaxsbHhLuamGd4LnT3Uwc8qCALirNTRYHoEwzC87nG1Wg0SIyWKLLf8PGF8IEpbW6F2yFGCEAJZFD2r1r5SSk3Q7WT2/Plz/Pzzz5iYmMAnn3wCWZZDL3DDaB3O0Uxz4PS5FEfeV2GAeoF+sfjiBWKxGEZHR4d6XkGSQHS9ZRkepRSGru8oX4wnEphfWMD8wgJsx8HK8jKWlpawsrqKZyyqkM1mMTEx4VZAMEO2Fidx/+7y+xkU6VVVFTZrxFar1ZBMpdpGxghrYtXqyi3L8si8Pw2zVS7j+fPneO+999yfUwp1wAZsg8AbTQ4AZmRhGG4ZG1PBiqKId48fx5UrV3DkyBGMjY6GH5CBQd5s8NiW5TVSisdioXwFuoUky+7AEwRslkqY6FQ/7YsWtANXFquq2uh5zkLylmWhCncnrjCi0MxmutUCxo1cOjnFDQKyosCwrIGQg7CgdLt50oEDB3D69GmPaIWeEne9WqE/7MlqhQEsSNRx8PLFC+ybnR2s+VYTCCwk3qoBk2kY3oYoqMHhz71pmognEjh48CDmFxagaRo2NjawvraGR48e4cH9+0gkEl6zqFyrZlFc+R/GF6GnTxsesXgcVqUCh1Jo9XpDkzsAO6+zzXXzqIE3B7LX3rx5E/F4HAvz89vnfUsO9h5UthPWdd3zxyYADszN4cH9+7h18yY+P3++9xMEBg+lrrc34LLJQTFGx7aRTCZRq9VQqVYxOjLS+sEEmkYLOkFgauNYLAbbtmGYJnSmTdBNE7ppurXRigKVkRXe3rrVA1WrVmE5zlDFiByqorjmKANILYSZ1BzHwdWrV/Hs2TMcP34cx44d62lRGm61QpPz97lL58tVVCZIkSwoA4g8LK+sQNN1zO1CfbsoigAhcJgmIDhWguWLjuPAZBsAm5kVAQAohSTLiMsyspkMJvN5AK6Oa2V1FcViEcVCAU+ePAERBORzObdUcmqqsVNsyCiCt9kaUDRIYCneKutsq+t6Q8jfv9kj7LqbjXfHcTwzOy9q4DhYXVtDoVDAmY8+8koyCSFvIwd7EaqquqV/uo60P/QuCDhx4gQuXrqE5WIR+T5ygv6dcpUJEAVB2MlKI4TjOFBVFaZlwbQslMpljAZD9ZT23E45CFEUEWfVDLZlQWdpB5v5pOu67pZQMaIg+nqv+1EulwEMvuFSMxBm8kIphW4YkfZa6KR295onra7izJkzLdu2hlLN+yfagaNJ2LWPts28ft09dETXv0dTCi8WF5FMJDAy5JQCsC1IBHGbBxHfxsGyLFDbdv+wzYzNLI15hFGRZciK0tIUSRRFt2Pk5CTw/vuoVCoosAqIGzdv4pdffkEylcIU6/8wPjHhapYYUeFtj4PwE99Bpc9EUUQsHke9Xoem69tiwoB2pZ0JEk8Ziz67aQfAzVu3kMlkMDs3B953BngbOdiTkFl+3HEcWH7lLqWYnp7G+NgYbty4ga8nJnr2H+ATusaMjgCErqftFY7jgMCtXNjc3ES5XMZINtuwa++230FYiJKEhCQhkUjAYuzbYDsOm5VHCoLgahQUpSGtUq5UIA2YOLWDoijuDilictAO1VoNFy9cgKZpOH/+PCYmJlq+NsykOMzIgdAkrdDPpO15HHThvtkJlLl57iXYloVXL19i4dChIZWc7oTAcua243hdHCmlqFQqXpt4IgjedyKJImRfBLAbpFIpHD58GIcPH4ZlWW5UoVDAy5cv3WZRkoRcLudWQOTzHZ//QZaWAm4qgLum1up1pJJJt5ldMKXQBNz9kR+H49XLl1hbXcVnn3/e2NaZkLfVCnsRPIder9dhmqYXbuN4/4MP8Nvf/AbXrl7Fhx991HN9v2Wa3gOXYANtUHD47ksQkE6nUa5UYBkGKsx1cJiLhyRJbuMnuu2hbpgmLNuGadvQmDOZoqpQZRnlchnJIZkfNYMiy6gRAstxYNl2ZG2cWy2YGxsbuHjxIgRRxFdffdU5YhIinDpMh8RmE2Q/k/ZA+ipEcKyon5Xi8jIM09yVlAKHKAgwCfEc/EyWFqxUqwCliMfjIIQgpijeJioKSJKE6akpTE9N4RTc0uVCoYDlYhHXr13zPE4m2WtGx8Z2VEINY+6Kx2JwbNvr4phMJhvGJddtBJ9Hy5eq4XqNUqmEy1euYGp6GnmWeuFQFGVP6WvC4o0nBwA8cqBbFmKBxWB0ZAQfnTmDn376CRnWJrVbUJ/RkTKE+n3KGi4JhEAQRddSeWMDW+XywFsgtwIhxBUpyjJ4IxfdMLw20vVaDXUAG+vrSMbjsCxrV8yICCGuIRJLi0gDNKZZWlrCjz/9hCxrnhRZOdMQ0wqRaw64QO41nCy7weLz58hms0NzAQ2CMldAXdehaZo7JxHiRvUAKPE4spnMUBatTDqNTDqNo0eOwLQsLC8vo1Ao4MXiIh4+eABJkpDL55HP5zE9PT20EDwhbpOmSrXqijB1vfHc3P0x8L6gEFE3DFy4cAGJeBxnzpzZbh7FnpPXsYwR+BWRA8D9UqksN5SoUEqxf24OpVIJv/zyC1LpdHuHuiZMUtM0z+gorPtWP7C42psRnXQ6jc2tLRi6jnK5vCv5fD/8FQ92IuE5qFmmiVKlglQ2i1K57DFvWZIgy/JAoy1+KKwhlWmawIC+r4ePHuHGL79gemYGH585E/qzkRAL7zAjB01LvfqIHQwkcrDHYFsWlpaW8M677w7tnJRFwizLcn1KWKthyzDgAF56T5ZlyKqKVCKxK7tZWZKwb2YG+2ZmALitrAvFIgrFIq5du4arV69iZGQE+VwOuXweo2NjAx0rXHSt1eswDAOKqnrna3ZW27a9SAx3Xf3h4kVYloXzX3zhbXj816y8hnoD4FdCDkSWSzNZL3GZNxjhNf8ATpw4gXK5jB9//BFff/01stls84MFJm/qOF4v9Hgs1mdLmnCgzLeBD0CBEGQzGbfMaHPTDY/tkZ2ZIAgeUbAsC7ZlIcnCmZT5sZumCVKvgzCdgixJkGS5K1vobqAwW1ebTaZRRDD4qKCUes2TDh8+7DZP6mZyC5NW8F46jMhBk3NEoDmIrFJhD4oRX716BdtxBtqFj1LqjV/+h+tV+KZHEEVILKSdSqdd0yNRbFq+uFsYGRnByOgo3jl2DLphoLi8jGKhgKfPnuH23btusyjWKGpycnIgu3BVUbzukTuiB2gcY37TIyII+Pnnn7G2sYHz589v6ygC6Yi3kYM9DlVVXSGabTc4hhHf3x+fOYPvvvsOFy5cwB/8wR+E+lJ51EASRbexBlP7DhLceIP4DJ4y6TQqrCHTxuYmxsfGBnoNYcGFZ5RSN1cHIDsygpFs1jMksUwTJlNQ67YNwzBcQY8geFEFSZIiJTyKLEMH3NRCFBMlm6x/unwZS69e4YNTp3Do4MGeDhVWjLVrjZf6UR3s4bRCVAr5xcVFjI2ORiq69ZMB/rf/Wiml3vPCdUCUUpTgChIJIU1Nj/YSVEXB3Ows9s/OwnYcrLGywEKhgMUXLwC4aWBu6zw6MhLNM0DdVtK1QPQgON/w3iyA65ny6OFDPHv6FB999BHG2/jMvCUHexyqqqJSqUA3zZahf0mScO6zz/Cb3/4WFy9exBdffNE2HOyPGgyzVMXxRQ68CYIQjIyMYHVtzWvn3G3/8kGBT7q6YXgPIt+9SJIExGIeeeBkwWKlVrptQ2dkQRBFL6ogM//2XqGoKnTThGGaiEdQ1aHrOi5cuIBSuYxz585hamqq52N1WqT83/ngEa1DYpSRA+7pH9l9iKC2Xtd1FJeXcfLkyb6OQyn1auktPxngviWsXFqSJIiSBEkUvTSjB07EKIVpGN6mYk91Bwzcc06MRUHA2NgYRkdH8e6770LTNFerUCzi0aNHuHP3LlRF8QyY8pOTPWm9+PlkWYbYJnrgOI7XYEkQBKyurOCXX37BkaNHMRcoS3Yobehn8bq1aub41ZADhXUa5G17+aIfTAMk4nGc+/RT/O6773D16lV81KaCwR81kPkDRwgI7d/rvR1s225apphIJqGWy3A0DesbG55hyV6BrmmgAGJNmDQXCsqyDMTj4N3OeFTBZjsm27YBXd8mC4woSF2SBZm1cbbZBNwPkSqVSvj93/wNHNvGVyGbJ7VFh0VqmJqDZvd0r2gOCCGgERKkKMrnll69AnUczO7b1/V7+QLE9QJceOxPI0m+yMAOMhAA4V4HgFdJNcxmZ6HQZJwTsDJsQQBl+f1YLIb9+/dj//79cChrQV0ooLi8jOeLiyBwm0VxspDJZDrOB5Q7NzIEowdBV0seNdB1HT/8+CMmp6Zw/PjxHccVA+d9HT0OgF8ROeAiOcM0YfGSRvhqUX0YHxvbrmBIp3H02LEdx2sXNRikgQeFu6CB5RSDGB0bg1EooFqtolavD0Ug2Qm834KmaV7kIMx7ePUDsO1IZrLaZIcRBdu2ocGdUESfXqGVeYsfqqKAstLLXsnBysoKLl26BEVV8RlrntQvOi13w4wcRK05gBNxX4U9hsXFRUzkcqEc8bzIACMEDosMOIBnFsSjAjxC0C0E5n5oMa+DvRw18EMgxEuHBOdSgRCMj49jfHwcJ06cQL1ed50ai0Xcu38ft27fRiwWwxTTKeRbtKAWBKHh2MHoAfcm4BsV7iL5048/IpFI4OOPP25qHR/EW3LwGkBVVRiVCgzT3H54faJEP/bPzaFcLuPGjRtIp9OYZupajqZRAw5CIKCLTo9dgLuboYWJjKIoSCSTsKtVrK+vI9HDDmYgEATomgaJ6Qe6f7sAhXWHBJiY0Lbdfg+m6e26LMsCNM0lJKzzmsRczERRbMgjKooCjbW9pkwk2Q38zZPOnDkTbRonsKvZ8TvsXrVCFGmF3TIGaod+r6heq2F5ZQUfBlrBU0phO45HaB1WZujND4wUUEJc7ZIvVdAvASSC4OpqRLFtw7TdAO982Aq85XSnzVY8Hsf8/Dzm5+fhUIq11VU3qlAs4umzZx6ZmGRujel0uuUxg9EDfh26rsNxHNy8cQOWbeMLX2XCjs+F7bEkK8rQqrCixq+OHGwJgmsVynKV7foAHD9+HOVyGT/8+CO++eYbr4JhN7QGFO7EyrustVPyj2SzqLHe5aVSCZldNB3iIHD93KMS5/DFXvWRhQZxo+PAphSWbcPwXQPYBCyyHK3DfOQt09xJ8lqAUoq7d+/izp07mJ+fx6lTpyKPFBHSurNlV9UKrUhGO/LReCUtr6/9aal3v/n/+1v9RqU52Et48eIFBEFAPp+HpmnbJIClB/zpRn7toi9NEAUZCIITEiIITdN5uwaWfm3/ku0NEO9T0AkCIcjlcsjlcnjvvfdQq9VQYP0f7t65g5s3byIRj7uixslJ5HK5hkU+GD3gBMWyLDx4+BDrGxv44osvEG8WIeSpEN/n2lORmi7xqyIHnoqXCd4a+o9j5zRIAJz56COvguGbb76Bqqrtowbem6ONHvAHw+GTaxtyIEoSstksNjY3sbG1hVQqtSd2DIPshuh5nLMJkKccbMdxc7hskobjwKAUxDRdUxjDgKHr0HQdmVTKLf/yRRmCiyB1HPzMmiedOHECR5lp1rAXqmC+tMWLGv9u9fsezh3m83Kvfu//eUqBkIZ8uHctvvLiXUEXC7O38Ns2LBYVePbsGcZHR72Ng58IiIIAwUdKRRbVGnRqyDBNELgam70wBwA9Svgj9wAAnEFJREFUpl1ZmqXb9yUSCRxcWMDBhQU4joNVFlUosGZRgiBgYmLC0yokk8mG6AGlFJZp4uXqKl69fIkPT5/GWItKMCFovwxXB/a64ldFDgBXOaprGkxfCVu76IFXwfCb3+DixYs4f/58+KhBROJEvvPg/wbaRw4A15WsWqlAMwxsbGy0LbUZFnRdH5oGwt8QhYOXg/mJg9eWWtehK0rDbpcQ4k3ioijCcRxcvnwZGxsb+Pjjj72202F2NFGBe1ywD9S3ur4Tmve77+3zBsWIOyb6FuI09x+kgcA7jjOUngqURessXzqgISXArrter2NzawsnT570Fn9OBkRB2BWNhWWaAIuM7SUhYj9EmvfJ6fW9+Xwek5OTeJ81i+JdJW/duoUbN24gmUxiamrKc7e0LAubm5t4/PgxDh08uKMywY9mn2s3mm5FhV8fOVBV1AXBa5AUBol4HJ999hm+++47/HT5Mt45etQ16wkTMuqzPGpHP/awYjRe2ri6ii2WWtjt0katXt/Vh6WhfJIhnUpBFEXohgGZ5Xp5ZQS1bZjMea5er+OXX36BYRh4/4MPkB0ZQa1Wc01l2MQvtNCBtMKOVro+MRr8fwfe4/88g0aUPgf+yEHo93j/oA3/73UcBBoIHXhUo8t7w1N2hmVti11ZRKDh0/rIPte0iIKAly9fQhRFzC8s7BmDIU3TAKbVGU7Zawh0MR+2su4WWNVZr+fnz1AqlUIqlcKhQ4dgWZYXVVh69QqPHj2CKEmIxWKoaRrGxsZw/MSJlocVmqUBCcHYHtiU9Yq9MYqHCFVVQUURNqv7FXy7xHaMdmx0FB999BF++OEHmIaBj8+cCXU+0mqXFAItH4CQx4onEq6FseNgbX3dba+6i9BZ/XDY/OGwoKqqVxrqj2zwneL6+jp+vnIFoijio48+Qjwed4WQrPbcyylju1Uu3y3y/hc8fyoIAkRCPL/2puOizQTqL2PcNXLQ47zsRQ6i2EXz57bJRXHi4P7YNSWjbLHn35dDXY8E/98AYFhWw0RPHWc7CsDIACcFxEdIXr18iampqT1DDEzWTh2s6qfX3Xbk6HLw7CDQYCngXivC2kSIp6amMDU1BUopypUK7t69i8LSEiilOHHyZNtx6z8qj0Sn0mlIeyhi0y32xkgeIgghUBQFtmHANM0Gt7BOAy6fy+GDU6dw6+ZNXLh4EZ+dO9dcmBI8J9xe391M5U6LvK63OIRcGEZGR6HrOmq12q6WNlJKoem6a4CE/uvJo4Qiy6hrmitk9E1GgiCgWCzip59+QjabxaeffgpVUVwdgy89YbBqCS6CBIC2cSlGEgSWexcZoRB8fwuC0JQkUN8xhoIIqxX4AhUFOeALusNC/DsWfb7gB9N6rCqAsOgCtW3XK4GV20q+VIAgCBAlqaN4slQqoVQut91ZDhXsWeOeInxc7zZ6WtBb3HvHcXaUIoY6VojXE0KwurKCF4uLSKXTyE9NIdmmoV2rufh1TikAv0JyALi6gypT8/vJAVdSt5oKLMvC+Pg4PvvsM1y5fBm/+e1v8fnnn3c2vWHixLADmXbx2k5QFAXJVAp2pYL19XXEpqd3RZjES4F4Celeih5wpbjB9Ae8ouLhw4e48csv2Dc7i48++sjTMAT1DNyxkmsY+MLEf+4tYOx3YK+14U4sZpsweJA0UFZrLfpTY4Q0RBL8Ku9+0fwo0aQVgo5/fgEfFzMGd/d+EuZ/f6ur4mFogRAQUfRSP35yRhgRIIBn8d0NFhcXIUvSnjEdMwwDjm2DYG+RA4e2L11shlavFwSh+1EYRkRLt3ujzO7bh3gyCVGWdxgbBa+x2ZFbCRdfF/wqyUEsFkOFkIa+3EB7YSLgThwE7pf+9Tff4OLFi/j222/xydmzO3wQggi7W6Zwy4867Qy7echGRkZQrVZhGgbKlQqyu1DaqOs6gG0R516LHqiK4pY9GgZURcEvN27g0cOHOHL0KE6eONHy+/DC1mwcNRNCBl8f3OX6w93+xRBgqQ3L8s5v2TZq9fq2yK3JmPXGs/s/jT9ji2PD75r83jufYyIGFRZsUFAQEFfAKekNizj/bAgu8j79RLVe94ysNF1veJ8/RA/A3c1zhbrv5wB7Rlj9O1/gBUGAADQSAFF0f9YNGWZRBX7ejosqpXjx4gX27dsHshfq2Sn1njU1FvNIz66TgxCli10fkh03zGcLo1OwTBM/Xr6MwtISjh8/jtGxMayurUFWlAZX3SCaHVWSZaRbNe/rAbOzs3j58iW++eYb/OY3v2n72ps3b+LUqVOwbRv/9t/+W/zxH/9xT+f8VZIDSZJAZNkVnFnWDiVvs+iBzYRJfAGQJAlfffklfrp8Gd9fuIBTp07h8KFDrRd1NiF3GsidFNi9POSCILiljRsb2NzcRCqR6MltrR/oug4Q0pjG2UPRA1mWgXodmq7j5o0bKBSLOHX6NBbm5xvFbk3e28034tcetANfWC3mzMbz5oS5e3qNYViYvN0izU7sP3jotIRFbSRoEjZ1AOomFPSahjpq3gIeCtR1maOWBaoonl+HP4rgERYWaePljt7i70+5sM8Qte6Ck9agRbVHUhynwbJ5fX0dlVoNp1nlym6DR+gIIVBluYHo8VD8rmCA5KTTPEIpRadZpl6v48KFC6hUKvj000+RSCRQ1zSoigKBEFi2jWby81apjWzEKYVPPvkEf/mXf4mff/65qQ7Dj3/0j/4RbNvGoUOH8A/+wT/o+Zy/SnIAbJc0WgFy0Cp6wJtuSD4hkihJ+OSTT3Dz5k1cu34d5XIZpz74oOVOpdNu2Wmx+ATBSUo38Jc2bm5tDb20UWc7RX/5516KHojMEOna1auo1Wpu86TJyR271mGB7+6DAjfZNEEphSiKSKfTO9/o260HQ/X+33th+w6/ExwCCxYc9h8FIEiCJ7TyRxoI2kcrbEZa0ul0QxlxLwv8wAR2LZ5/v2W1P8qx+Pw5YrEYJvaAKp2bs3GtgaedYd+NQyn2htNBFwhBQGkHF8VO42tjYwMXL14EAfDVV19BluXt1syKAl4C3fTcLc45GjE5+PTTT/GXf/mX2Nrawv3793GsiaU/APyX//Jf8D//5/8EAPzZn/1ZXyZMv1pyEIvFUBcEGLqOeCzWMICaCQh5fleW5R2piPfeew+pVApXr15FrVrF2U8+aV42SAiEFiw2rM6g52WKEIyMjmJ1ZQVbpRLSmcxQa581TfMiLn4IguA6uA1LYNcElFJslUr44YcfYNs2PvzoI0xyYhDuAIO5sECo3f1nB0Gqb/GK4o46jo0tbHnkAACUuIpkl+Yu3AgIQN/tt3edULLvwLZtLL58if0HDrhum0PwXWgH3TDc6gpCGp5tgUcPdonk9pXSCCkgbH+I1jvtV0tLuPzjj0imUvjss88gShKq1SoAd5xalgWw6EAwtdC0fJFhNGKy+Omnn3r/vnz5clNyYJom/vE//scAgC+//BJ/62/9rb7O+doRyaigqioEttBzUyMPTQaSxZikJElNf7+wsIDPP/8cK6ur+Pbbb1Gr1ZqfuJX6tgUzbYkeJqF4PA41FoMoilhfX+/6/f1A17SW1sm71YSHwt1NFYpFfPvtt1AUBWc+/hjJZNKLFIXCABeE3a5OF8jO76aXagX/Tr/v0PYgQ9RdvPbFy5cwDAMH5+e9BUjgKZEhL8TUcbyup2pgswN2v3ejnLFvh9gunq1mVSWtIlOUUjx48ACXLl7ERD6PL7/6ynO/BbZtj7k3CoCd0YMW15ZKpSK3TT5z5ox3HT/99FPT1/z7f//vcf/+fRBC8Od//ud9n/NXSw4IIUixsKyu6zvYrf9r9/QGQNtc/eTkJL755htYloXf/Pa3zRdgNoH40c2Oo9tSxiBGRkYgEoJavd6awAwAmmG09HYfZBfLIHiEhlcVPHv2DBcuXMD42Bi++vJLZNJptw8EE3WFO+jwFquh7/2ajbMePq83biMgBnulZv/x48fI5/MNZW5eWoY0VpAMGlzTIwnCjoigwK5jEI3gOqHfT98NyaJoHF+t5hWHUly7dg03btzAkaNH8eknn0AURRim6UUxY6rqOmH6ojB+ctBuzsr027K9CeLxON5//30AzcnB2toa/tW/+lcAgL/7d/8uPvzww77P+aslBwCQSKVAJAkO6+7nh/+h5rtIUZLcwd5mwGYyGXzz9ddIJhL47rvv8PLly50v4mpxNOaFhwFe2igKAtY3NoY20eqa1rKNLUFExjgtwO+xV2rIKgxu376Ny5cv48D+/Th37hwkWfaiG6Zpep4FHY8/sCtvdrLt3PduoZcRG5XHQZRlmv1gc3MT6+vrOHjwYPsXsu+LRxQGQSQd2/Y2OM2eMV6xsBtphb7R5XfN9Qfu/zTRjpkmLnz/PZ4+fYpTp0/jBKtE4pEXgOk1mE0zodRLEVt+ctDmGkYGVMLIUwvXrl3bEcX4F//iX2BzcxPJZBJ/+qd/Gsn5ftXkgBCCGMudttspcr1BQy+GNlBjMXxx/jxmZmZw6dIl3Lt3b+dAZfmqrtl8QEXdC0ZGRiCJIkzDQKlc7uNI4aG1SStwRDl1BUsG/STIcRxcuXIFd+/exckTJ3Dq9GlvxyGKIiRZBgFghIgedGo7GzX4PRrmOYORrl6iPFxN3m83xoEvbyGv7/GTJ4jHYpiamup8SGwTVK/8EgAiIuZ87pJEEXKzyCZPKwyTHERE4Lq9Yk9Q3kQPUKtW8e1332F9YwOff/455ufnvd/pug6HCX0VRXFLjFnEWFYUL1JgM5+SVs+AxJreDQKcHNRqNdy6dcv7+e3bt/Ef/sN/AAD8yZ/8CWY6lNWHxa+aHABAnKUWLMtq2m+BYic5CANRkvDxxx/j2LFjuHnzJq78/HPDAkXQg84AiIT9C4KAbCYDURSxtbW1I2oyCGj1ettGVVHsCCm2a+B5dCB4t0zDwN/8zd/g5cuXOHv2LI4eO7bjvDz9wZXfbTHoXayvFG23ELRQ7ilyEFFaYeDppxDHN00Ti4uLmF9Y6GnM+lMs/U7Ajm03VCg0gwB4u+OhIaLvqZeRT7EzHbG+vo7ffvstLMvC1199hYlczvudzfxNAObDQoi3MyeEuWaycWtbFoQ23TSz2ezAoqB+UaI/tfDHf/zHsCwLs7OzniAxCvzqyYGsqlDYolVnYSUO3sub7w679U0nhODEiRM4c+YMnj17hu++/RZbW1sA3AlCEMVdE5yl02lXNEMpVtfWBnouSik0w2iZVuDo9V7wCAzXEbSalvjOoVwu4/z585idnW36OlmW3QmAuRG2P/ngd2P++7IbkYPg2XrqE8K7ie7xyEGYq3u+uAjbshp2nr2Ca5m8tEOX0DTNm5tazU98sdp1I6QhwV+t41CK+/fv43e/+x0SySS++fprT2vGoTEhp+y7h1YgDcarFGzbbnsfB2mZfOTIEc918fLlywCA//pf/yv+23/7bwCAP/3TP0UihJ1/WPzqyQEAxJmgyGKCFD8sywIo3dYbAF0vCPv378eXX34J07Lw13/917h58yYMFo3o5MoYBJ9M+gYhyE1MQBQEaJqGzc3NKI7aFAYrsWq1s9m+pO53yX6b4nbgOwdKKb766qu2Pg/cQAaEdCdMHBCCnRvZD4d2/mDFQi+RgygEiZTSwe9+Q5TFPXn0CNPT051btncBv3V7WH2AbVkwTLNt1ABgZlIYTlpht/UgnlCQEGxsbOC3v/kNbt68iYMHD+KL8+ehBO4Tb6BGgIbv02GupGKAHHS6h1GXMAbxySefAHAjB5Zlee6HZ86cwR/90R9Feq635ACAHIt5pi5aYDHglQQN1pk9PADj4+P4g2++wTvvvIO7d+7gr//X/8LK8nKjqUpI9GKC1AySLGNkdBSSKGJ9Y2NgC6EnlupADoDwxkgOy/+F2Q29evUKf/P73yOdSuHrr79Gqk0TFQ41FgOo61C4o222D3QYk2GTzzjMKTj4EXtZYnjkoB9y0G1L7EFgbW0NW+UyDh46NNDzkBCRBE3XQcB2vG2sm/3i50FimFVHrcBdRa//8gv++je/AQXw9Tff4OR777nRwMYXb5cuqmrD723Wm4L/jM//Xn+UJkgkEogNuLEdTy3cuHED/+7f/TvcvXsXAPDnf/7nkT8bv1oTJD+ILCOmqqiYJgzDQDwe94RTzUoHOQvv9ssQJQnvvPMOJqemcPXqVfzu97/HwoEDOPnee665UohjRP3opdNpaJoGp1bDyuoqZgbQmIk/gGF2WnxSDE4yzVz/OoFSikcPH+KXGzcwOzuLM2fOhP5sgiBAVhSYhgFd11t3sxzWZMh2Q7tiZBO8lF4iBzxM28d17IWg+OMnT5BKpZDz5awHBX8kgetpOCzLgsWjBh2eK6/DJwZroTwIYtAt4SgsLeHqtWvQNQ3vvfceDh8+3HIzpxuGdz+CkRcuRuSRA6/xWZtridoyuRk4OTAMA//sn/0zAMDf/tt/G+fPn4/8XG/JAdhCEItBYnbKuqYh7lsMmg6tHlmaQymymQy++vJLPH36FDdu3MBSoYD3P/gA+2Zmwh83QpY4NjrqNtMxTayvr2NiYiKyYwPbqv9ejEH4o9htSJQ6jts86dEjHDt2DMePH++azMUUBaaPMO7anpW4/QX8xGi4O+jGxcSh3YX2G657t7z9I4Cm63j54gVOnDw51PPyeydgmyR4O15Z9hawdhCwXTUxEAyKuIY8pq7ruHb9Ol68eIHcxATOnz+PZCrVMg3l2PZ26SITIfphszJGjxyg870bHUIXxk8++cQjTKZpQlVV/Nmf/dlAzvWWHDAIrMbdsizouo5YE0vlfsFzplyZv7CwgKmpKfzyyy/44YcfMDU1hdOnTiHeRlTSrwlSM4iShLGxMayurKBULiOeSCAZobCF5/SaWko3gdcRj1Ud9HK+n376CYVCAadPn8bCwkLXxwDctIvI7J15t8bdgncXdkFzEKxW6HYPH5U74jA8Odrd1WdPn4IQggMHDgz8OpqB33XLNGGz1tJhUnXA9nwxMHIwoON2au5FKcWzp0/xy40bACE489FHmJ2b2xYlthBjaroOClfI2Wxesm0b1J9O7vC8CYIwUDEiRzabxTvvvIM7d+4AAP7hP/yHPc9vnfD60viIQWTZU6n7LZWDi/COSboLNNMKxONxfPLJJ/js3DlsbW7iv/+P/4FHDx+2rIEe1MMdj8eRTKUgiSJW19bcNsERwWEh8VCExicw7IUYaJqG3/3ud1hZWcFnn33W14NDCHGjHYR4pU47Lrfno3eH3XxQd5CDrq05oiljHAZaaUgcSvH4yRPMzs2FJrmDAKUUdU3zXPzatQdvwB4wjuoF7a66Ui7jd7//Pa78/DOmp6fxf/vf/3fM7d+/c84OzCOWZXlVSK1SMrzMnHcD7YTMAEsYg8jn8wCAXC6Hf/7P//nAzvM2csAgyjJsUYSqqqjXatB1fcdO0V9Z0O2jRimF06bB0PT0NHITE7hx6xauXbuG58+f48OPPmppqDGIsPLY6Ch0XYem61hZW8PU5GQkxw1jFMRDz/y13DWxm6ZMpVIJFy5c8CoSojAj4X7rlmU17+k+LA0AG3u7IfjaYffdY+QgTPh7t9FqpC0Xi6jXagPbpYWFputu9FEQvHA4L7lu95QQ4LUlCEHYjoMH9+/j7p07UONxfP7558i3mat4h1OH0gYRoqooTckVdRxX7AxAkKRQo31QrohB/PTTT/juu+8AAP/yX/7LgRkuAW8jBw0gsgyVuWE5tt2y+Q4Furf1DCFglGQZp0+dwtfffOOWPf6v/4Vbt241llcOcnEgBOPj45AEAfV6HVulUiSH5ZNZy9+DsfsAiSBA6J3R8vIyvvvuOyiyjK+//jqyh4YLEwnc/hBBDC33z+6P9+0Pc6Lv0yGR5337uVe7LUZ89PgxsiMjkbfi7QaWZcFglT9xX56cgkVlhk2+doFsrK2v47e/+Q1u376Ng4cO4X/7wz9sSww4eBTSMAzYtg2BkJYpGV6pQAQBcrP5J/C5RVHEZAinzCjwJ3/yJwCAkydP4u/9vb830HO9JQc+CKoK+AaNHjBFArZZaDfotj57Ynwcf/iHf4jj776L+/fu4X/xskffpDyox1JRFGRHRiAJAtbX172+5v3AobRpyI2nDjrdm06f1d886csvv2wQk0YBlaUWTGax2oBhRg78TWWGc9am5+q2WoHfs77CrkOMmATPVK3VUCwUdjVqQMFM2giBrChe6fUOsMqEZgQu0jEz5MoZ0zRx/do1fPvb3wKE4Kuvv8Z7773XthGeH5yY8lJ1lfVPaAaLVSoIghDqM+YmJ4eSavqP//E/4ttvvwXgdmAMnVLqEW/TCj6IkgRHUaA4DjRdb2qnDDDBXLedFLtk2ZIg4Ni772JmdhZXr17F73//e+w/cAAH9u8f+KDIpNPQ6nXU6nWsrKxgemqqr4k9GDWhjgPKJrBOd4UAbj/1JgSCUoo7t2/j7r17WFhYwKkPPhhIXluWZYiiCNuyYBpGw45jmDvaYFRlWNhhgtTlouA1XepnpznEhSh4lU+fPoUoSZhr4ag5DBi67uXB451Kgll1C4AdAtZI7uKQicHSq1e4ev06DF3Hyffew+FDh9yywi6Po9XroHS7f0Ir2LYNMNtk7761+LwCIZgZ0Lio1Wp49eoVyuUy/uqv/gr/+l//awDA3//7fx9fffXVQM7px1tyEICgqhB0HYqiwNB16IbRPFfKF7cQE15PeWJCQChFOpXCl198gadMkbu0tISFhQVXADOosB5LL+hLSzAMAxubmxjvI6fm75TmlbWFIAbe5WBnvTNvnrS4uIiTJ0/iyJEjAw3xq6qKmm27NtAhFeJRg1dx7Da6jhxEYIC0W5/boRRPnj51SXmX9umRXYPjNHiFhLqPXK1PBtBTYUjEoFKp4MbNm3i+uIh8LofTX3yBRDIZ2ijND9MwYJgmBEKali764bC0ww7TJAb/O0fHxyO1LPbjP//n/7wjdXD27Fn8+Z//+UDOF8RbchCAKMuwZBkxx4Gh6zANA2jCMgVCQrX07UdARnxsf35hAVPT07hy+TLu3L6N58+e4eixYzhw4MBAIgmiJGF8bMx1hNvaQjweb20E1AG8SqOfUjS/8ZRhGLh08SI2NjfxySefYN++fT0fNyxUWUYNALVtWJbVdZ+NyLAbpYw7zvXmChIBNOyMX718CV3TsNCpNfMAUa/XAWbCE7T/7QSuj/KIZb8L+xCiBptbW7h39y5evnwJUZZx5swZzM7ONsyH3cC2LPcewnVC7PTsGqYJh9K2rpMc++bmurya8Pj5558BuBuT+fl5/J2/83fwT/7JP4k8bdoKb8lBE4iqCpimm9fTNJcg9MgOo3iMOFOOxWI4cfIk5g4cwKuXL3H12jXcvn0bx44dw8GFhch3NolkEnVNg1OpYHV1Ffump7s+B7cz7VdlT1jNcblcxoULF2AYBr744guvEcmgQQQBqqp61Rwpfh+GXD3gmQkN8ZxBI99uqhV462zg9ShlDOLxkycYn5hAOtCsZ1jg3v+UUiRYe/muQch2KXE/pDJkKrBXrG9s4O7du1h69QrxeBwffPAB5vbvb7jmbqMG1HFQq9ddTwNWjdbp9bzMsZOvSXZkBJkBVgv8xV/8Bf7iL/5iYMfvhLfkoAkkVYWtaa6lcqUC0zCa1twL3KynTXohikXRfxyBEKQSCXz04Yc4ceIE7t27hxs3buDe3bs4fOQIDh06FKk4ZnR0FLqmQTdNrG5sYLIL21jKPAt6sZpuhrW1NVy8cAESq0hI9jpZ9ghVUaDrOky2sxAI6WjSEjU8c5fdNEHq4vNGYYA07PJNnsLaKpexsrKCjz/+eKjn5+CeBoDb66NVmLtbCKLYdbt4CoAMiBisrq7izt27WC4WkUql8OFHH2Fubg6CIHjzB9A9MQBcESe3SE4kEh3tmG3LcstCBaFjhGGQUYO9gLfkoAXEWAxgde0GXHvOHa6BTBfQlo13IVxsBwGAA3f3ReHW+iaTSXz44Yd45513vLrfe/fu4fDhwzhy+HDXIcim5xUEjI+PY3l5GdVqFZV4PFTjIk4MAJeN92sQ8uLFC1y+fBmjo6P4+OzZXcn7S6zBDS8pi7HmTEPFnuitEB59VyrshrcDO9/Tx4+hqqpra74L0FjZImni/d8t/N8hP2Y3WoRuu8d2AgVQLBZx9+5drK2uIpvJ4OOzZ7FvZqYhwuQ/Y7ebDF3TvChAIh73jtuSIFDqVjMQAkWW247ZZDKJsQF3YNxtvCUHLSCpKsxqFfF4HPV6HfV6HVYm05CHInAXbABNWyn727D2DUZEBF5K6RvciUQCH5w65ZKEhw/x8MEDPHjwAIcOHsThI0f6zlGpsRjSmQy2trawsroKVVVbRid4GNn/8IUVbrY63v0HD3Dr5k3Mzs3hww8/hCgIQ2k/2wyqqsKybeiGsS1sGua18Pu4i5qDbgSJfqe5Hk8+fEJECCzTxLPnz3FwYWFX0iG8xwsFXDIewfcdFLQK/DkKc38j+g4o3C6pd+/exebGBkZHR/Hpp59ianq6+RzB3FKJIHQ1h1iW5ZUtxmOxhnRoqwiEIAjee4LVDNxrhlvfT+9i5cqw8JYctIEcjyNu25BlGZZpolqtIpNONw5Stmg3G3DN7JL7AeElSoQ0bSOsxmI4efIkjh49ikePHuHhw4d4+PAh5ufncezYsd5zlgBGslnomoa6rmNldRVTk5M7JnzP8jgwkTiU9mTQ4jgOrl+/jidPnuDo0aM4ceJEdMKqHqEoipvDdBxX/TzgstIdYDXYw0QwrdBN46XXUW9AADxfXIRlmrvibcA9DQjbwUYifm0yD3nz0yAqGgJwKMXLly9x9+5dbG1tYYI1R5rI5drOkdxvoFudQb1WA+A2pgpGUJt9Ui6Y5jbpwfdwciCxMsgwxkuvO96SgzYQVBWkVkM8HkeFhZI1RWmoM24I1wX+fxALmMiMOdo9zIqi4N1338WRw4fx6PFjPHzwAI9ZOdaxY8d6E1ex8salpSXomoatra0Gtzh/GiEI6jhdK9VN08SPP/2E5WIRpz/8EAvz89uXAkAMWS0SNbinfV3ToOn6wMqYWoEKgpvKGiaCk3cX57f7rFTYDbtoh1Lcu3cPM7OzbZugDQqGrrvPEi+7iwBetLFVvX4POoQwsB0Hi8+f4969eyhXKpicnMSpU6cwHjYk32X5LqUUtVrNM16LNYmaEh7ZDIxr7oAqiCKUACGzODmQJMzMzg6tj8Ju4i05aANBECDFYpBrNSisY6OmaW6bVL5j9KUOCBpD6IOY1gRRDF3vLskyjh07hsOHD+Ppkye4f/8+nj97htm5ORw9ehQjIyNdnVuSZYyMjmJjYwMbm5uIx+NQVdXroNgK3aYVavU6Ll68iGqlgs8++wyTzVg6L88aQqe+IFRVhabrninSUBvx8J34ENMKQh+JsX6sk3kkatgmvYuLi6jVajj36adDPrPP04BSxBKJaCMu7Xbo/Bn1P1N9pHQs28azp09x7/591Go1zMzM4MzHH3dlP90LMdR1HRazP04yAeIO8LnDJ/KmAAwm/pQDKQVKqRc5UBQFU7ukQRk23pKDDhDjcUiSBEWWoTkOwJgp3337B5m/uYm/PXOUENjAbpZWaPkZRBGHDh/GwsICnj9/jnv37+M3f/3XmJqexjvvvNNVOWA6nYamaXCYe+Lk5GRHn4VuyMHm1hYuXLgAAuDLr77CSJtSoV7Uy1FAEASoigJN16Fp2lDJQWQali4Q/O660Xt47og9LHKEC36HCEop7t29i6mpqYGWqbUCr8cXJamti18v4JVVLeEzduO6oW7HmmlZePL4MR48eABN1zE7O4vPP/sM6Uymu2vt4Xs3TRM61xnE421Tfv65g//N36sGnmdODERBwMzs7O55nAwZv45P2QcEQYCSTKJarUKWZVAwsZBheHWwzYSIwGB2d1xzwB0Gu3mEBFHE/MICDhw4gBcvXuDuvXv47W9/i3w+j6NHjrg79BDXPD4+DmNpCZqmYWV1FZP5fNvP6oQkSYVCAT/++COSqRQ+++yzjjaxBPDKnYaNWCzmljVa1u6aIg0FfQgSo7BOHiJeLS2hVC7j9OnTQz+3aZqwTBMOgFTURjckXE8Yb7MjCCBdPFd1TcPTJ0/w8OFDmJaFA/v348jRo6Eqm5pB6FJ07Nj2ttGRouzY/bcCn5dsy4LB7PKDpMyybYBSiJL0xpcv+vEmz2iRQUkkvJp2WZJgWRbqtRokSXJzqb7wG48eDGrBEthuykHvu2YiCJjbvx9zc3Oecvj777+HGoth/9wc9h84gGwm05IoCIRgZHQUK8vL0HUda+vrmGiTQ6S0eeMlP548eYJr164hPzmJT86eDb3YNrNWHga4W51p29A0redJ8HVAcGEPSw4aPA56EG4O+zvlUYNcLofRIZlr+c/NGyvFVDVyoWtYauZF+Sjt6OFhWRZevnqF58+fY3l5GUQQsDA/j6NHjvSt1eBdWsO+tubrmxBGpxEsi9QNw91sSNKOuce2LIAQTE5NRR7N2ct4Sw5CQJAkyPE4tGrVM8ewLMtNL6RSDboDYLBhX8/ljPVvJ4T0XtZHCGb27cPMzAw2Nzfx7PlzPH32DPcfPEA2m8WB/fsxOzfXWApJKWzHQTwWw/j4OFbX1lCpVCBJUssUAGUlmK1+d/PWLTy4fx8LCwv44IMPug5Be/3sh7w7jcdiqFarME0TNvPEGBaGuRMP7jlpU733Tvj1Bj1pDrp+R38oLi9jc3MT586dG/KZmacB8wPp19OgJULME0IwTRrwQ3AoxcrKChafP8eLly9hWRYmJiZw+vRp7JuZCb1jbwU/0Q/7/Wua5rVhTsTjPY01XddBCdnhiuj4KrDmd9FCezfwlhyERCyTgVatwjQMpNNplCsVWKYJwzCgKMrQyuv8E63tOJBEEUI/BME9KEZGRzEyOor33nsPy8vLeP78OW7euoUbN25gcnIS+/fvx/T0dEO9cTKZhGVZ2NzcxMbmJmRJaupa6LA65SAs28aVK1fw8sULnHzvPRw5fLinB5sAu+J9IAiC26DLMKBp2nAdG4dKDhoR9jZHYYA0TNy/excjo6PI5/NdaXr6hWVZMJinQSweH9x3GyLCtuP37NndWF/H4osXeP78Oer1OtKpFI4ePYr9+/dHVrGzg+SH+P5Nw/DKD2OJRKiIixfJpLRRb0DpTnJgWaCOg9Hx8V2z0N4tvCUHIRFLJABB8CaNmKpC0zTUajVIsrxzUeMhuU4Oij1AEEVYTBy5fbru2ki3PLYgYGpqClNTUzBNEy9fvsTz58/xw48/QhAE7Nu3D/v370cul4MgCMhms7AsC5VyGSurqxAlacfOh7Iohx+6ruPipUvY3NjA2bNnMduvqUgXE0qUiMdi3gQVi8WGFz0YwLhqjYCfRZdphddBb7C6uorVtTV8+umnQyVe3NOAu/INTLvS4TN5C7PvZ3VNw4vFRTx79gxbW1uQZRmzs7PYv38/RkZHI4/UdRv98zdUUlUVcsh7J/C0Cft/HvkDITvSBibTIczt3x/6ut4UvCUHISEIAsREAnalAtOyoMRiMC3LG6BNOxb6KhciNUNif2zH8b5ALwQY4eIoyzLm5+dx4MABlMtlvGA7h2fPniEWj3v6hNGREVeHoWlYWVnB1ORkg4I/qDkoVyq4cOECTMPAF19+2Vc7aA6CbYvpYUIURcg8etDMYntQ4OmlIUWr/Ag7xrxWzcM2iuoB9+7dQyaTwfTUFKKv9m8NQ9ddf4EIPQ1aod0M5Ng2CCGwbBuvXr3Cs2fPsLKyAkIIpiYncfz4cc/4J2pSwKsiuhln3TZU4hCwna7ggm5d10EByJK0PU8xzYVt20gkk5jooqfMm4K35KALxJNJVGo1WJYFhZkhVSoVGLoOmbF+v+6AAp5KOEqCIIgiYJo7avy5GDJKgsDNjVLJJN45dgzHjh1z9QnPnuHZs2e4f/8+stks9s/NQY3FQCnFMiMIfBftUOqZ4KyuruLixYtQYzF8/fXXkQr5CHH7Bw47vRCLxWCaJgxdRzwWG4pBCuHjauBn2qk5CHtWr1VzD+N+mN/hxsYGisWi22BpSIQLcEvk6vU6CNzSu91ykaSOg5WVFTxfXMRLpiMYHx/H6VOnMLNvHxR/aR9bMKOay7y5qoWDYys0a6gUBg62SVJDSsGvN2BROWrbcBwH+V+ZEJHjLTnoAqqqoiLLXjMPfxtfLk5s+oCHLCMKCx6mbTaBBgd+P6DAjlAjATA6MoLRkZFtfcLiIm7dvg3qOMiMjGCMmSvNML90nlZYZM2TxsfG8Mmnn3Zsifq6QJIkyJIEwzRd18Qh9VsfVpWGEDRIDEsO+rFOHiI5uHfvHpLJJPbt2ze0c1K4Zl9EELzo0yDhEUnffd3a2sLzZ8+wuLiIuqYhlUzi6NGjmJubax0BY1HAqATA7brZttpQtWqo1A7NRNEE2LZMptSLPvCmVLZtQ43FkG9iFf9rwFty0AUURYEgy3B8QkRFVd0Wvo7TfmGIcEfiOTC2Ek35ohW9goKFGtu8RhQETE9NYXpqCsapU3j58iWePH2KJ0+f4vGzZ8jncjh65Ags24ZRLmNxcRFzc3M4/eGHDQ2sogQhBELEu5sw8KIHmoZYLDa4PPuu9JTozQSpHwOkYaFcKuHVq1c4ffp0V0K4fqHV614of1hkEnCV/S9evMDTZ89QLpUgKwrmZmcxt38/RkdHw3khwH327T4IAmVtkduep8mx2zVUankuSiGSna6yFPDmbn+LZj6v6oaB/QsLu9IBdi/gLTnoAoQQJFMplFltu8yEiLFYDLVaDbquD1ZUxCAIQtvF3/9I9TTNsVRCN4+9IstYmJ/Hwvw8VtfW8ODBAxRXV/G73/3Osyfdt28f3n///YERA47dqF6Q2PduMovtoUz4Q/p8vWgOuEMosLfJwd179xCLxbB/iIIzg20uKKVIJJODTSdQiq2tLSy9eoVXhQJW19Y8HcEJpiPote+FKIo9+7kIotj15sWx7bYNlVqhGTEA3HlC97Vo5nMGgUsa0tksxsbHh1uFtIfwlhx0iSRzS7QtC6ZpQlEUd2HgnRtrNWRaWYVGVMEgMDFapwez17Bzt8QgiInxcciyjOnNTZTKZdy9cweA61n/4sULjI6NIZ/LIT85ibGxsYGQBW69O/Dl0/c9xmIxWJUKdF0fbPTAd+5+I0ScYHittr0fU+/3iqNAgQKH/daxHViWtT1GfOW1vNS2wQCpy8VnWOZH1VoNL1gZ7bAIjMM7BlIKNRYbyEaiXqtheXnZ/bOyAl3TIBCCbDaLE8eP4+DBg9E8c74UQzcIMy/tIKSOg2qHhkrNILQ5F4XrLwFKoSiKRwwopbApxdyBA0gmk3ua3A4Sb8lBlxAEAalUCiXLQp0JEXn0oGJZXuOUlqEotrD303eB7zTCPJQCn6jDCnYiqu/OZjIwLQuEUoyMjECSJHz04YdYXl5GcXkZjx8/xt27dyGKInKMKORyOYxks5GlA3jucFiQFQWiJIFaFnQmThw0mooSmVEVpRSObcNhu3jvb8dxqzoCk6Zfxe1HnCaQQQbsXXB0G5VKpe17uNhOEEVXqEsIBEFwo16Bfzd834ykDAP3792DxCpyGjAgUkfhEhIATUt+e4VlGFheWcHyygpWlpdRLpcBSjEyOor5/fuRy+eRTCah67o7RiMk491+V71sWKjjoFKtegLElg2VgufqcH3UpzdQVNUbw6ZlYXrfPiiK8kY7n3bCW3LQA7zoAQDDMKCqqstmYzHU6nVomuZOiG0YZz8LoMDa9nIL5U5HImFLHLuwLA2DsdFR2LYNWZZRYb0p5ufnMT8/D0optkolb4dz68YN2MyEZHJqCrlcDpP5fF8GKwTuvRqm/iCmqqgwchBT1YGd17ZtWLYN27Zhm6br5OYjAJ4Ilker/GW18InTqOujD2xXu7h/bf9tExsGDFBQt3KBuGkbr5GPb8zwf9mOG2cglLr2sz74G97wEjZBEFxrcGbqJQgCREEYWMi9Xq/j2bNneOfddwee5uLQmMIehLjjusex4dg21tfXvWdnY33dTVGkUsjncjj+7ruYyOcbqgxqzA+gl2ZK7cC/vzAbkG6IAU8JNiMGUVlLayylQAQBCjsmpRTxZBKjY2NIp9NDd13dS3hLDnoAIQTpdBqbm5vQLAsKU9UqigKTNeOp1mpIJZOtH5g+BIqEEHdCt+1wwh52vrYmSWy3GXVVxfj4OFRFwebWVkOJIyEEI9ksRrJZHD1yBLbjYG1tDSsssvD82TOAEKRSKUzm88jn88gFJrwwIOgvN9oOzSY6RVEgMjtXnl7oBw7b/du2DZuFVm3b3u6e517IdgkrrxBgO3K+6ApsofX+HUgDtJsENbGOEkpe5IDESNPUGU9NAO5iJAkCJFlGTFXB2y877Nptx9lO+/AIBwBqWds/oxSSIEBgPUxEUYQoipGEeR88eABBEHBwYWHH7waxHJimCZ21BE52qzOgFCX2/CwXi1hdXfXKqXOTkzhw4ADyuRwSbXLjlJmmDSrVJYR4xnqKGNRqPRGDMJ9S0zRQX5UC4BLWmdlZiKIYmfPj64q35KBHxONxVCoVWI4D3TQRY6VI8WQS5tYWLNOEpmntc2N9EASBEDiA9+B0QluTpB4EiGEhCQIymQwKy8uwbBsrq6vI5/M7JilREFwdQi6HEydOwDBNrLDJsFAs4tGjRyCEYHRszCMLoyH1Cnx3M5RwNUsxVatV6LoOtYvogUMpLGasZTuORwr8sBghpJR6jb+4pbXASBcnAJF9pJBdGf0kg5MyVVFaptg4mXB4qoP927Jt17YW8LqgWvClMCh10xWCAJEZ13DCGQaGYeDpkyc4dPjwUNptO46DWq3mbiBUFVKIcwZ1A4amgRCCifFxHHv3XeRzOWRDpuD8vQoGthOmtP0z1qXOyuHEgPVMCEsMaMj50LIsL5rCxcOUUuSYgduvPWoAvCUHPYNHDzY2NqBTCoUNSm7KUa5UUGM5144GGj0IFAXWDdLvktjxmt0L3/EADzorH4vHYVsWBLihvLW1NeQmJtq+R5Fl7JuZwb6ZGQBAjU2WxeVlPHr0CHfu3IEoScjncsjl8x31ClHZS4eBqiheMxiedmoGTgb4n6bhdybA4rvmuGlCEASMZLPeZBmsX48aO+5piHOF6avgj24A2E5T8GMw0mDzyAkzpaEsjG04DmBZrkiNEEiSBEkUITHleSs8fPgQFMChw4c7fo5+4dcZCKLYUmdgGQZWVlc9QtBMNzA+Pt6TuNPTHaFHz4mQaEsOunjuqOOgWq1uE4NkMnTEQAxZBVGt1TxXRO63kkynkR0dhSRJjc3mfqV4Sw76AI8emKYJEwB/7BVVRcy2UatWUa1UIKTTrXcLTKCILhcuiZnuWJbVlZlQkCDwkrNBLpmqogCUYnR0FBubm6gy/UGrLo7NkEgkdugVisvLWPHpFWKqivHxcWRHRjCSzSKTybghXJZ/F/qszQ4NQqCy8lZN16Eoijdx+smA6VP88wVeYiRAFEV3dyyKDRM6r/EeBsnxPk7Q5yDEe3jEo58IBifbfkU/jzRwomDbNizLggPXa9+yLDiaBpGTBfaHX4dpWXj0+DEWFhaGYsKlaZoXBUmwpkqWZaG8tYWtrS1slkrY3NgIpRvoBVyt385UKDIEqhcoZQ3XuiCuvCrBtCyIXRIDASFSF8T1QOHkgKcOBFFEbmoKAN5GDRjekoM+kU6nsb6+jrppQonFQNjgTCYSbrc1w0ClUkEqnW5ftsQe4rCDkivAg7vNsOBK3kETAwDe55YYIdjc2sLG1hYkSXJ1GV3Cr1c4FtArrG9s4MGDBzBZpzZZUZDNZpHNZDAyMoJ0JoN0p+8iAsRY9MDUdZQrFe+7Ck5efMfr2W/3sJh6quxBTWjBsrIOE7Bf+9ANOWhaebHjUohHnvzn4wJNHoHh6QiT3XNOFp48fQrLsnC4XdQgoiiMaZrY2txEuVKBoWkoVyrYKpVQLZVA2T1NpdMYzWZD6Qa6hRctw/Z3NvAlj81hnoNiD8TAsm2ITLQZWmNAiFeK2OZFoJSixnQMkq899vS+fa5TpSy/jRowvCUHfSIWi3lte3UAfvlZMpkEdRyYloVyuYxsJtN6sJPuLJYlSXKV4Cz/3A3TJYAXmh0GeFrFMAyMsC6O5UoFq6urkESxb9GeX68AuBOhpuvY2tzEVqmEra0tLBeLePT4sSd0S2cyGMlkkM1mkWFEI9ZjL/ggHJZOMAzDtcj1tXMWfDtaWZIiU16jyx1aNwirOeDw6yS6IQe9jkbiu6dg4kceUTAty40ywN3FP37yBFNTU3AohWmaHskOHLDra7BtGyU21ra2tryxZ5omKKWQZRnZTAaT+TyyR4644y6TGVgNPbcG9lemDDxywMHIWDffJycGXBQdTyRCuR9unzIcMQDgluFS6vVBGRkfRyyRAKW0tUfNrxBvyUEESKfTWFtbg2YYiCeToGzXSgQByWQS5XIZtuOgxAhCy91hF0ybEAJRkrxQarfCKgIMzWGPh9X5bn50dBSWbaNWr6O4soLpqam+w6d+EEIQj8UQZ62nOfwT+PrGBrZKJRSKRbfWmbiNV7KMKGSyWW8CD1MX7tg2DMvyqlW4SyPgEgKRqa27mfC6+szo0Q0zBILiUUrbT/uebXK3xCei8egnCzF2PbZt4/adO7AtCwvz87Bs2/ueZFl2HfJCihrrmoatzU2UWFpga2MDlUrFK81MJJNIpdOY278f6VQKk1NTiMdiwwtVk8b2y9zcqlNVShSg8OkaQm4+KKWo1usNxCBsBK1Zz4Qd8OmN6kwLBCZylGQZk9PTnqHdr9UquRnekoMIoKqq14CpappIiiKobbspBlaOV65UYNs2yuWym9OKYMcgShJIj+TA4WFo/98Dgj9yALi7ydzEhLcwF4pFTOXzA+98JooiRkdHMTo6igNMu0ApRb1edyMMjDAsFYu4/+CBN5mm0mmMMLLAiUOMdaA0dN2zw+W6AkopRFlGXFEQi8XckqmQKuqwCE6Hg6R53S4ne62ngiAI0HUdTx8/xuHDh5HL5WCYJkzDgANXh2AYhlvvLkmePshxHI9Mlra2sMmiAtz6mEcDcvk8Dh85gmwmg0w2u22P7DhIp9PDvw/BVKHv2R4kOWiohuCppQ7no5R65bkELNoa+oTNeyY0Owe/jkq5DMLSCYIgYP/8PCyWmn0bNWjEW3IQETKZDFZWVtz+CskkJNuGwEoHqSi6BKFchmlZqFSrSKdSzR8c/rMQAkXeItqyu+tAT+FzQuTnGCBB4MTF8OkjBEFAPp/H8vIyDMPAUrGI6cnJobVG9Rv+JBIJJBIJTPuiDJZloVwqeQvC1tYWlpaWPBKgKAoSiQTUWAwqa8CVSCSQSiaRyWTcz8HIgmmasG0bmq4PLJ85yMjBDs1BhzN5rZr3CDkAgNu3b0OSJBw9etSt+hBFxBQFlWoVlUoFlWoVuqZBMwzUqlWUSyUvGgBKkUylkM1mcejgQWRHRpDNZj2BoR+8+RaFuwMeJjEgQNO8u9cdc5BRg2BalFWhtOtvwvP/fmIgCgKskBEHEoYY+P5t6LpL2uBqwkbHxyEpCizL8tLDb7GNt+QgIsiyjEwmg1KphEqthkwsBoGFr6jjQBRFJBMJVKpVNxddrSLOlPRNEeJB5jX+FhNghX3025UbRe2gBrhhaVmSYHKlPYMkih5B0BlBmMzl+tYgRAFJkjA6NobRsTEA7j3TdR0bm5solUool8soVyrY3NyEruteyoQQAkoIJEFAPJFAPB73HDQVRcHY6CgSiQRiiQRiihJtadmACJ6Axmt0QpKDsAujv6dDVLAsC3XmVrq2toZnz55hYmICV65cQV3TUGM+FP5rEAQBaizmRgRGRjCzbx+SqRTGRkaQSCY7ppccx3Fr5wnxUhVDQ5tn1xMjDoqotBJTt6nC4sTA8hMDUQw1DkKlErCTLFeqVQCuWFiNxTCez8OyLIiiiBHWZv4ttvGWHESIVCoF0zRRr9dRrteRUVW3lIgNZFlRkGAPRV3XQZgYrylB4BN9m9Acd4uzbRu2ZYVS4DdEDZqADIggyEy0GQQnCCsrK9B0HcWVFeRzuaH1JfDysy3useM40A0DuqbBoW6DlolcDvtmZiAxLQXgag40TUNd01Cv1byFSavXUa1WUa3VvPQCPzchBDFGIBKxGGLxOOLsTywW8/7NF6Vh9RwIYodUtsN1dKs56MagilIKwzC8+1uv192SUU2Dpmnus1Wvu4SZNjpHapoGQRCQSafdyoBEAvFYDDF273m+2bJt6JoGg6XsKNxwtCTLUFW16XNGKfVMdbjmZaho80zzVNcgohi8IqIV8WjmnBgkBolEYnuMd4oadCIGbN4MjiabaZzAyiMnZ2a8535sbGzPpMD2Et6Sg4gxMjLiqqRNE2XDQCowQaqq6i4kuo56vQ6RWczyTosNCBM9kCTYjtslrxM50HQd/+//6//CVqmEXC6Hf/Nv/k3T3ZBpmvjTP/1TPHj4ELIk4Z/+03+Kd995p/OHbwNVUWC2KLuUWPOl1dVV1DUNxWIR+Xx+KG2P+SIdBLc/5r4C1HFARBFxFn7k7+EpHUEUkUgm3VK08fEdx7NsG+VSCbquQxJFd4Fj5KHOFrnNrS1o9bonlOPRIEVVXaIQi0EQRZdkJhINngiiKLphfEFo+nNRFD0b4n7Dy+32+dyHANgWMjqsesAzMmJ/894QDhu//tfwagObkS7/wu/4SiUBNBCpXC7nkatEPI5ypYKrP/+MT8+dw/T0dKjPJxDXyVBRVXcccKJg27CqVYjM2Iw3XQPc1r+2aYIyjdEw6+Q7kflBkUqP1LVZWIPn5hofPzEI+li0O1YnYtDq/RVWTixJEsYmJjzn2pGRkaG4ZL6OeEsOIgZnoqurq+7EZtuIiWJD7i2eSMBhO6BqtYpUOg2Iohu8bUYQ2jwwkiRBNwxPVNMOqqri//5//B/4//6n/4SVlRX8/ve/x9dff934IkrxF3/xF3j48CEIIfh//Z//Z9/EAABkVW0aOeCQRBH5XA4rKyuoaxqWl5eHRhAEViMNuOFojecm2SIkiCLiyWTDYuAhpL+AxBYUXsUw0YRAcJjMervGSINWr6PO/myVSu53zZ0DKQW17cZWy36hKbtGnp/l5+cGSwJzFRSYFbHkM1/ir6tVaw3Xt/jiBS6vXfb6PVisGylfzC1u/+w4rgEQpV70rKGNNt/lBULPoihCZERGEkWobPEfHR3dXvjZrl+NxVoujBTA1atXMZHLhSYGQYiM9MUYWTRME7bjuMRO06Cy1ty6rrs6g3h8aLvQVhqDILy0QoSExcv3dzgmP6df/MvJbzNi0Gqm8yIfHVKiTd/L7KspgFQyiTFW8pxKpd56GrTBW3IwAHBV/NraGnRWtSAHduiJRMLzQKhUKkinUqCMILSsu24y+D0zpJCixD/8gz/A/++//lesra3hr/7qr/DFF180RA/+03/6T7h8+TIIIfh//NEf4ZOPP+7qs7eCIssNOd5mEAQBuVwOK6urqLMyx/z4uOcRMEhw/3udERjeuyDGctAt0cWEG4/FYBoGLNuGYZotc9KyLHv+7kFsbG4CADLZLETfztxhC7W3OLMFumE3zp0F2a7dCezU/bt4Q9e9Hgd1rQ7LcUBtB4QA5UoZZbviRSYU1gZYZJbeDtPY8HAxT3/9/9t7sxjJrvS+83/OXWPPtTKrKjOrssjivlY1ySapptQtQO2xPa1hSwJkzzwYFqAXwwPLgAEP5t2GRp6xrdGDZQi2ZNiwPGq1x2qP23I35KZEqsnmUmQ1q7lXkSx27blGxN2XeThL3rhxI+JGZGQt5PkBgVwi4q4R53znW/5fkfoj5V0YNV2XpYTTmsIuXLiA3U4HXxvzM1w0yVBNQ6VahS3CTPyz7DoOuq4LU9dRrVZvWp6BFBoq8Vox6U7LaCmTCJh/fZIk0jAA2AIp7+kcdi500CJJGJhDFlBdx2FGFCE4vLIiv9dF3y/FHso4OCBMXjO/vb0NJwxRTZKeSYbw2JfQQBAVDClvhVvoPiv4gogBVQz0w5KmkiSBrut4/vnn8Xu/93u4fv06/vyFF/DVr30NAPDd//Jf8N++9z0AwF/9q38Vf+XrX2dvnIJb0jRNphc/AlHmuLGxwfopbGxgEZhISbEMCY9FezynIOV5BYNiy/uB8hwTESs3igR4ypLxDFBCmAcA/f0JpsH3f/jf8fHVT+Sx3nPyJH72xHOFrw2CAI7jQDeMUvcsFUlrUyaKIvzkJz/B2urq+MlmQ7x1hLdmty0Lnu9je2cH4BUpQqHxoNU3AYylbDotz4EoVRz305WmqQyXAWxhZAzI2yj459Ck7VJ9FLpdIE3RarVYszZdx8zMzE0N/dyJqCyMA6RarTJtcMOAGwR9q3tCKer1ukwq7Ha70pUt2vL2kftAE0KgaxrSEd6D7KTx3HPPSXGgP/nOdxDHMV555RX8+z/8QwDA008/jb/xq7/au899fpEMw0AQhqVeSynF/Pw8W3kSgus3bqDd6exr/0UEQYDd3V24noeEG28zrRZqtdqBDfCWZYFw/Xl/SJhlECPvwi2uVhCfwdJljAcUD3/3vfcQRhEefPDBsd9LSh5THMewLQu2ZUnZ4263C0fkRRwAk3QXnYax2KNhMAYJb6Ikwp7VSqXQMAAKFDKHGQYod14iOTWKYxxbXwelVCUglkRdoQNG1rwbBjqdDpLcBE65BgIhBGEUweEd3MQgkPA+7D1k4nhAOb2D7BeJEIJf+uVfBgDcuHEDv//7v4/f/d3fRZqmeOD++/Hrv/7r/cbAPgcY0zT7ShmHIQyEer0OjVLc2NzEbgnPQxniOMZuu41Ot4uIr8Bq9TrqvJyKjjEAjztcipUnIUR6K8bbQLkY7zQZp1pB1tTfQuPAcV188OGHuOfkyYliymmJa+h6HpvwCMHMzAxmmk1YPCdFaGT4vj91L84krdX323RpUsMg4iHTmF+n6ogQXV+lwgDvaTJG6Wun00GUJJidnWViZjMzN8Wz83lAGQcHjEhQ1E0T0DSWGFMQGqjx7mBBEMDjJVEC0T8ht2FpQIjQwtCkxNz7v/zkk1hbWwMA/OAHP0AYhlhdXcXf+43fKP7y7NN7YBqGbIJTFsoT9+r1OnRCsLG1hZ19GAgJLzfb5pr3Sco6OTabzb5YsVb2XCe4JpZpyjI/z/PGfj8wfNU0bQNhnN4KyRieg4PKoj937hxMLng0CaOOy/d9+EJMp1KRDbMq1Spr6sU7afq+L7u27hfRxGiSO5umKcikpYxkMsllPwjQ7XSYMihfABlDpImzyY1ib3lRpYF6CgMIeEVYFIZYv/tuNJvN20JD5U5BGQc3AenKsm3EXJwljyhPA9iqJJu8N9CLQAgIzzInaVrY9U/Q919C8NWvflX+2Wq18A/+wT8YvdISXovhr+pDNwykQOnQQpaF+Xk26BKCza0tFucdk3wIQTcMNBuNwZr3ZQfFSSY4QuR19j0P8Tgx91sRJ83tc5i3YxwBpIMQ5dna3sbFixfxwIMPTrxCHHaFwyCQBl3FtmHkVPU0PhFWeRVDCsBxHNYJcEJjiKBE/f8Qsr0VxtvxZCEM13XhcQ+obhhS4KhMuWW2hDd/HOMei1CkXVhcxOLiIur1+ljv/6KjjIObhGEYTG3PNJmMZ4GL3eLxS4DFysKCmLT0ImS+KBqloLqOFCjMOyhKUrt69Sq+/e1vy7993y8/mAqvRblXA2C1+gAmXkXNzc2h1WpBp5S1fN7aKvW+NE3R7XZZCIHXVjcyIYRhEAxIDM2+ZsLJ2jAM6IYBQmmhsbgfpm0+9EWYBtz57ABexjiYtt8gBXD27Fk0Gg0cO3ZsX9spIooidF0XKZj3Z1iTHtOy0Gg0YHFNjCiOmYt7ghbr+/WwTPz+IeJgxS9P4HS7cmyzbJvlXJX0IlHkDAPCBOQmOf4wCLDNW2Pffc89SgFxApRxcBOpVCqocznevHyrfE21CtM0kaYp03vPvUZ6EbIGAk9KHBhayH252u02/o/f/E20221pTXueh+985ztjnc84BoJpGCBAoVFUlpmZGbSaTeiUYmd3F5sjDATRCdMPAsRJAtu20Ww2xxM9GZUUVX5LfQjvQRCGpScNeSQjBsyp1rSXzDkQXgNSVmhpylUKly5dwsbGBh5++OGph1biOJbyu4aul1JAJJSiUqkwrxefILsDvveF7wf2nZOR8m2M446XrxvDsxPz/AKRh1Gt1fpc+KP232cYFOVblSCNY1zf2ECaplhcWMD6+rqqTJgAZRzcZGZmZmA3mwAhcLrdwlVjtVqVqxLhkiyynrNeBJ1PvkWTTPadvu/jn/zWb+Ha9euwbRv/8B/+Q5w+fRoA8P3vf7/0ilxQ1kCoVqsAIeg6zugXD2FmZobV+FOK3d1dbGxuFr4uCEPs7Owg4gJBjXp9sra5hLDs9UGD1D4Gb6ERQAmR0rvTYppDISW9w8Qgz8E4IYVpew2SNMW5t9/G4uIilpaWprrtlK+ICZiYVY1/lssiQg0m9xT5XO1xWJhhkqqEIhL++SeElAv1lBQ3yhIEATrdrlQRrdfrhQb4oNCIyKeA2K8490mqI+IYW9vbcDod6JTi1OnTpVquK/pRxsEtYH55GXalwjLWufZ+vpqgWq1KdUDf9+HkXiNel6Yp4mxSYkYtTyD+TpIEv/3bv43zFy6AUor/9e/+XRw7dgy/9Eu/xKolwhD/73/8j2OfT5kJ1zJNVGwb7d3dsbefZ6bVwuzsLDRK0el0cGNjQz4nNO47nQ4SnoTVaDT2J5HKczsGPbcfhIxrzIWRyhwLMNpVfBDNjOS2B/xfljGWGIynvZI7f/48Ot0uHn744f1vLHtt01SK6FBCxjYMJOI7bdsApTLMUBQG3G+OQZY4YYWnZe/JOJ8ZkV/gOo5coAwL1xV5lETnWrnNouTrksT8mu5sb4NoGk7ccw8OTdlQ/CKhjINbAKUUrcVFVCsV5mrnMsr5L4Vl26hVqyCEIAhDtNvtvlJIIJPdy11x+deIgeZf/at/hbNnzwIAfu3Xfg0PP/IIAGB1dRVf+tKXAAA/eOEFXLt2bfyTKlHN0OBdK6dBs9mU9crdbhfXrl9HHMdodzpweZKfaZpo8FLI/TIo/2C/UxylVBqKruuOHBjL7o8QUqpzXaltlaxWGMtzMMVKhSAM8e477+DYsWNotVr73p48Mm4YiJbC1Vpt30mUpmWhUa/Le9Npt6VRKFz/07w2SRwzCfARxz2uYVCUX1At0aJaGgeZcxXnO67HIksYhnAcB7vtNlJC0Gg08PipUxNtS8FQxsEtQrdt2LUaakLjIAgKJ3/TsphQEhc5ag9YbQht/DRN4WUSGcUX/j9++9t44YUXAADffP55PPdcr8Ld888/L2VO//hb35r8xIYMMs1ms5RKYlkajQbm5+agUYp2t4uPP/2UlZilKWrVqjSspgnF9EvwbC6MlKZpaWGkg/IKFJG/hmlavKotK4Ak4uDT4r333kOUJHjggQems0F+bLK7I1CqZXNZNE1Do15nJZCaBs9x4LjuVD0GAlHhNPDYhRt/jG3GUcQSfHl+QaVaHdxdtoBsF8c0TaV3Y1IC34fnuqxBVhDANE088OCDTF9GMTHKOLhFUEphVKswTJNN/po2cPLXdR31RgMaV9brtNuIClzQpmEAlCLgK+cEbHB44YUX8G0eLnjuuefw/De/2ffe1dVVPME16F9++WVcvHhx4nMbNEi0mk127CX7QJShXq+j1Woh8n10XRebW1uoZtrvTh1CpuKJyG9TJG+5U1bXm8aWynoOREnmyCqQKRpsXcfBhx9+iHvvuWd6NeyENVLyw7BHy2CaEEpRr9VYdRIhiIIADq+EmCYiLynfPlsmKI75WZP5BXHM8gtqtbEm4SSOQTVNegz2a2h7vOw7imM4jgPTsjA7O4u7Tp7c13YVyji4pRiVCuuEp+tSCTBJErTb7b7EQk3TWOxc15EMqGTQDYNtA7xkME3x5ptv4nf/5b9EmqZ45OGH8Wu/9msDj+eb3/ym7FD4rT/6o/2dXEGYodFoIAVTLZsWURwjSVM0Wy1Yug5D03Dtxo2JxYXKMm2PhBRG4uGFgfsdY5sE0/mC9xkHBeO51OAooQ8xLc9LCuCtt96CZVk4effd09lmmiLk7bSBYi2DaWLzcj8QgigMp1rWmoJNxkma9hi0KXisHyjtxk9T1oNE5hfoOssvGNNoyucYTOonSdMUjuMg4CqUYRBANwzomoaHHnlEySNPAaUjeQshhMBqNuHxTnuNRkO669rtNmrVqtQHANhqo1avsy8Fb3CTxDEqXDyJEALLNBG7LgLfh2maeOyxx/Dv/u2/lWVCwwbuo0eP4g/+zb+Z9klC9JtvtloAIWi325iZQmw4m9RVrVYxOzuLGzduIIoiXL16FbNzc2geUOc1cS3TCVZfxRtkCWuddpu5RnlnxqLXAeU9AtOOYQPFvRWyIYWRpZ9TOp7PPvsMV65cwVNPPTX2JDUIoWUAjNYymBYGFwrqdruIwhAOYVLD+6WoUkHG+cfZTpLAdRy5YDEta7wwQpqysFkuZJJisjBKmiRwXJfJMoMZHKKp0/qJE1g+cmTsbSr6UebVLUYzDJh8AiOUosFLnkQylJ9bAYtujqLO2vP9nmRG4eILo6gnf0F8jZN9ZANPihhELMNAxbaxO4HCYZ6sqIzGG1iZpomlpSVUqlVQrqZ4Y2NDJspNnSlfR13XWWMmQpjYTsH2y+ocyJdN4bjypYxF+y6bjDgtj4vn+3jrrbdw5MgRHJnSZDCJlsGk5F36hmHISogoDKXnYj/ISgXubRRJh+Pcg6L8ggpPoB1JmsrJv8gImGQcSuIYHcdBHEUgYLow3W4XIARzCwt45PHHx96mohhlHNwGGLYNk3d1SwHUajVYfGByXLdQ58CuVFAVlQxBgE5Gx9zkDWCKktvEl3pg18eDhBA0W619N1DqMwwaDXlemqZhcWEBrZkZaISg2+3i6rVrCKeY5yAhzOE+zQBDpVJhyVppWjxBjDm5TuPY+kSQCkyO0pUKU/rMnT17Fmma4rFHH53K9hLeNl10OZ24ZHEUIjO/oI7fME1ZvpyVaZ4UUamgaRo0EUYYgzAM9/ILeI5E2fwC6Z0Y5kUa02gXnWsTcTz1OrrdrqxMevLLX1bhhCmiruRtglWvQ+erRlkTPULnwLIs1Gs1UK6M2G63EcfxnvdgSOa7KKUqbOp0EPD9tfZZzhjHMbo8lEBzhkGWVquFxcVFaJQiDENcuXLl4PIQpjmJiFp6sNXxIOXEce7Yflfr+fcXJUyW0ThIMZ18g8tXruCzzz7Do48+Ko3o/SAktsElfA/MMABGqg6alsW+95TCDwJ4+1AUTZJkIqlzgCX6OfyayJyoEqGbNOMtKEJc1RTjfYajKEKXa5doPBEyjCLpNfjSE0+o3glTRhkHtxFWs9mTVSy0yQlYLXdRy2fdMGQlQ8wrGSil7O80lbG4PnjskYINIjfLSGg2m3AcZ7xmQ5w0TaXHgBAiW10PolKpYHl5mYVpkgRXr16dms5CljI9GMZBNwypnDgovDDtkMYw+koZi3IOyngOpnCNwijCm2fOYGlpCaurq/veXpqmcLpd6fmoTUHLoAgZRihx30zLYmqevPIoKFnemiUFuydJkoxVaSGEhEQ407QsVEf0R+irPBiVcwIU6rUMIuChU4CFX+q1Gggh2NreBqEUd91zD46srJTenqIcyji4jaCUwp6Z6UkiM00TjUYDlCsYttvtvioFUcmgZyoZCHd5D+tlILwUlFJWY52mBx5uaDabQJqi027vyaSWxBVJSNwwKONCNAwDy8vLe3kI29tTzUPITpwUmNqkLcILSRz3ejwmmGCnvQbOGwfZ1eIwz8E0juPHP/4xwijCY489tu9tCYW/iH/ma7VaX8nfNBDiZOPcO9mETdNkJ9ExdghgL7+orCiV53notNvyO2aPyC/IlyKO0wuizPc+4WEEEV4zTBM1LrQkpNFn5+fx0EMPldqnYjyUcXCboek6rFar5wupcZ0DwzAQJwkcx0EnJ5hEMkl5aZoiiCIEQYAwCEoNLCL7XkoyH5CR0OJ9JUTeASkZCw3DEJ7nIRGD+BirO0JIcR7ChB0is/QcOyEyX2C/EEqZgiYhcD1PakNMOsHuJ7QwSudAhBSGNVwa5W4uw7Xr1/Hxxx/joYceku3NJ0WUwoVhiCRNUa3VoPPOplMjq3g4wfW3LYs1VKO0VO8NEeMX7d1FlcCo70rEmyYJb4FuGKjX67CG5Bf0jA28GqlsaWRS4noEvi+9hJRXbwhRM8/z0Ol2UalUcOr06alrUCgYyji4DTEsC2YufiZU1WrVKgiYe3U350UQlQy2ZbGwQhzD9f1ybkn+ZSWZn8JISERy0RQmPd0wUK1UenosjJq4kiSR+vamZU08GGTzEIIgwJWrV/edh5A/cgLuWp/CtTJME4ZpglLan5R6E8MKfY2XcvsWxudQcah9hhSiKMIbb7yB+fl5rK+v72tbwjCIokiqaZr76b0xiFxN/9gQIiXWkzge2c0x+92VlQpD7knCFxpdHq4klKJSraJWpAbJQyKFwkVj5jQMuyZZb0ECVjVSr9dlbkmSJNja3oZhWbj/oYdUK+YDRBkHtylWrQbdtnu/SITAsm00mk0plSy8CFlVxUq1iiof8KIwxNbW1lgx/uxkLWKlaZIgnoKiGQC0Zmb6Y/9CNKlg+67rygREkaQ5KSIPweIeloPKQ5iWgSCS0+I47klOG3vLB2hMjNNwaVJ+8s47cD0Pp/eply9yDIRhUM1n4E/zOk1hW1TTWEkl9yAVeQGLjGvZU2HAPREVTiJpWSi1Zq+F7HnAFwc9Z8O9BZMwaAzxM94CAqZMmTdUdnZ2kKQpVtfWsLa2NuERKMqgjIPbGKvRgFawotE0Dc1GQ5YyhrxSwfc8+cWzLAszMzPQNA1hEGBrcxM+VxMrTW7QEXkJCU90mtRQaNbrg8sZcyudIAjYcSeJbPu8X0QeQjWTh3D9xo2J8hCGeT2mUdNPKEWVC8542clhzGs/zbBCkuutUKqMcR8T5cbmJj788EM8+MADqO0jI11UJYSZHIO8x2AqobQpG2KmZUE3jD0PktgNsFeJkLu/gzwHohzQdRxZ+lyr1/uaJg2TNxZhkknOsqjSJeH6Ep7nSV2GRrMpNT8EIpywuLyMu0+eVOGEA0YZB7cxlFLYXFWwCMuyZCJitlWxWMkZponZmRkYpikVFTudTikvgkhoHDal9IQdSmZiA6w7Y6fTkQpnBTsHCGs05fBeA5ZtT3UwyOchOI6Dy1evTiUPIbsPSgjIPicLMTmI/INJ2zFPah70iSDl9j7KONjP2cdJgjdefx2zMzO4ex8SyUmSsJr4OAZJU9Tr9aEKlGOTjaMfQBlkrVIBCJM2931/pFKmyBkSq+6Uv6/T6ci+LJZto84bQBWFDQYZlBOfXZr25Ellj0mIGlUrFTQLOqmKcMLswgKOHTvGEpsVB4oyDm5zNF1HpdUaOPGKXASxCo5yXoRKtYqaGADAYrft3V1mpZeZtIS7f9BAIcIOaboXdhixXdFWtz2ix0IQBIijCJTSA1OrE3kIuqYhCkNcuXq1VPJXllGD5TSSFKtickgShNwlPi6THkGfBFJm36KrHnAwYYV3330XnU4Hp06fntj7kTUM0jTt+T70Mcl9EobBAYZuCKXMQABzvydxPDT5M+HnSimVKoee6zJRJJ7gLFbmhWGDoQcz2X3I7kPkFghvgc69BWaBXHWSJNjY3IRlWTg8RUVMxXCUcXAHoFsW7JmZwV9eQqQXwTQM6UUQ7ZENTYNhGLBtW1YzuPz5ovbPfZsXjxGlhzLswB+DXtvgwkXtYbF+vqpIgX1npo8in4dw/do17ExB4jnLfpXbqKbJsjLP80rdt75tkNFNkYrJhRWyv2caLk1bnW57Zwfvvfce7rv//olXisIwEN6NxjDDABMYUEMM52ljCA8SF0gahDhXQohcmSeiPJHH8UUDpJupkipCkZ7vy+6zBKy5VYN7C/JXMkkSbG1uglCKw6urWFtbU+GEm4QyDu4QDNuGzbsaDoLyxkzCixDHMdrttoxJhmGIWq0mRU3E8+4goZ0B+yiF8CZkww4cXddRq1aHJgKK/Ahd02Do+p4b9YAGM13X9/IQKMXWzg6uX79eLg+h5ORA97m6tCwLhq6DEALngLtOZukTQcqcw6hKhUmrXJI0xetvvIFGo4F77rln7PcDe70ShFJgGZW/sXNybtLkKjx0tmkCaYowDAcea8y9Sx5vwAawKqFGo9HTYXKkochLMadFzBUNZckkr0QY1mp7a2sLCaU4uraGEydOKBXEm4gyDu4gzGoVVqMxeADjX2TLslDPeBGSOIbvugiDAFEUweLCSsKL4HkedgvaRA+j7KDRE3bgK4c0TdEa1mOBew2SNJVd8YT3YppKhEXHuriwwBI5+QR8+fLlqcou71d9r8oVM6MogjeBch5QvDpOc48s/fd6LyEtimOkhEDTtMLtTjq5vP/++9jZ3sbp06cn8kiIxDshPlQvKs/LcdsZBmJyzhjXuq5LQ6woPyZJmYqo53lSd6PKq5dEHlFpxhQpG3YejuNgN+MtqFYqw8M7ADY3NxGnKY6urOD48eMqz+Amo4yDOwyrWoVZrxdm/WbRNA21Wk0qilFNQ9dxsLO7iyRJmJehVmNKg5qGhHsRipo85cnWU48z+IuwQ5qmaDQa2NjYYIN3bn9RFPUkVRZt5yBduc1mE4uLizD4dbly9SpubGwMdOWPcyQyyXPCQVfTNBmXdceQoZZxZVGexh9JuieYk30kmUd+1k+wV6kiwgrC6EkBpNxwSDMCQOOcbbvTwTvvvouTJ09idnZ2jHcyhMcg5ZNrGcOAHXzJHJyyr90HWUGyns86Iez+85BBliAIWD6R78tmRPV6HfqYGg7T/GZFYYi2MFbAdAsajQZMyxq6n63tbURxjKNrazh2/LjSM7gFKOPgDsSu12HVaqVc3qZlodlssj4EALqdDra2t+E4DpIkgWEYrE00n3B838duuz1W1r6QYR5nlXHo0CH4vo+t7e290shMTDLlXoNBA8h+KwBGIfIQqrUaNF5CdvnKFTiOs+9ti4F/0ui/aZosPksI3ILkSTnJg03+MffaxEkiQzxltfCBAhGkzO/CYNKzk6/YbuYe9RiRlA7cZwrg9ddfR9W2cf999w09riJirvYnDJZ6vV4+UXLYdcis4m8GwypSRPllkiSIokh2lOzy73SSJCyOP6Ap2SDEK6dxhhHvBdPtdqUcc7VSQbVSgaZpQyuhtre34QcBjvAcg7m5uSkckWJcVGbHHYrNwwtBtzvY7coHM0IIWq0W4jjG7u4uXNcFJazVs2masLk0qWkYrHSQN18RDWDKuHXlar7kADq/sADTMHDlyhW5KkgBJFEE3/MQJwlqI1Y82cHlIIZsTdOwsLAA13WxubmJKI5x7fp11Go1zM3O7is7X04047puuVFhc2MuDEP4YQgzI/2bFEzOfRNffkU6Dpnty4ZLRdci/1nIr7oLjumjjz7CxuYmfvYrXynVBTCLNAx4cuS4MtujwnUHnbw3KuFXQilMw4Dnedje3d3L9yCs3bQQCivtLRlRFjkOURgyz0UmRKmbJkzTZAbBiPux227D8zwcPXYMK6urWFhYmMJRKSZBeQ7uYCrNJoxKZbggUSabutVqocY108XK0fd97O7uwnEcWRYp4vwBzyou60Xo0UYYuRolWFpexpXLl3v+L7KwDS76Ile7KI6Hy32XOsLJqFQqOHLkiMyodhwHly5fRod3ips4aauElkT/W3hIR9Ng2zYSAJ1OB0EU7YUBymxnzN4UWcSaNhYhhUGVCmNOpts7O3j77bdx1113jT0pRLxcD4QwYZ8xDQMAhcbKgXsLspPzsP1kwj3Cw+Y4DlyeV6HrOho8RChKA4eSJFMNzxV5CizbRr3RgM0XGLSgGiFLl7//yNoajq6sYGlpaSrHppgMZRzc4VRnZmDY9l7/gyFQQlCpVKAbBjRdR000m8kYCZ7nweYuSZGLIL70pRUExaQ3YuBZXl7G5tZWT+w04pOckHElmYFTqjMOOFeSeUx7QCeEYG5uDocOHZKJnjc2NlgDpwnKCnu2jfEMhBRslawbhlwdOo4z1jmPc3XyQ7qYxKYpmxyGIV750Y/QbDbx8EMPlf4MAewz0+10mLqepsk8m7HJh0GmlZA3AEIIC7EU7SPtFSUS+SKh76PdbiMIQ2aUaRpM20a9VmOdW6MIKQ8XDqVkw7NRDDIKmtwoSFPWFn7UXew6DrbbbRxeXcWRo0dx+PDhKRydYj8o4+BzQHV2lhkIIzopEi4mZOg64jhGFEVoNBpSJS1rJARB0FNmFAQBG5QmyJAfNMAvLy2BEIKrV64A2FNcFIP8sG3l9RT6znrimv7h2LaNw4cPo9VsQqcUvu/j8qVLwzUbRjHKg8AniiSOkfKYsqDOs9BFE53STNACWB4Ov9rJtIyDNMVrr72GwPfx5aee2tteicTXMAylYaBP6jEoPKQDzi0QhkduP6nwDGDPgBPfy3a7DYd3JqWE7DVJ4tcmTpLp3ZMRjDIKCCFSqGnUlXRdFzs7OziyuoojR47g6NGjB3rsinIo4+BzQqXVgm5ZslxwEJRSVCoVUJ7tHMcxS0osMBLau7sQGvSapklBmXG8CHJQz2ZfcyzLwvz8PK4I40C0mcV4okFiVZVNuAMOboAnhGBmZkZ6EQiAza0tXNmP/LJIUsxOgnyiEMmEQq8i+zzhsXUACMJwZOe+/P5KvbSvtwK7rtEgZcQxr/sHH3yAK5cv44kvfQlVfi7Fx9H7uQjCEF0eSjAMA7VabWKDcFJJ6nGRx5f5/mSTRPmL+EsSJhi0u8uaLnGjoMo9e6Klt8j7ELLIOtfCyO14KscfhSE67fZgo4DfH+F5GXY/0jSF57rY3N7G4aNHceTIEayurk7lOBX7RxkHnxMopcyDYJpSeKgIwkuhRF5BdrU5yEhwHAearrPyI57IKPIUShsJ4mcuU/3w8jKuXrvGJsHMqmeSQV56FQAZgshOVNM2FizLwvLysmxwFfg+Ll2+zDrHTdDEiR+k/BkV3MfsdcnWvovVmjuGemLZq9FfV9EbVsgbcuPkM9y4fh1vnzuHe+69F8ujXMncuBSfQZfnfOi6Luv4J4UQwspqDwIR38/kC4jPqDCGe1+ewPM8tHlyXgL0GAXieyiuu/AWhLxyQZQu9mx7n5/9HqMgjocaBUQkqmYNnhxibNnc2sLykSNYOnwYKysr+zpGxXRRxsHnCEopqnNz0E1TrjiLvpwULMmOUIooinoauQDFRkLg+wiDALqus6SnTAiiO0a9fT5hcWlpCVEYMh0BPqAM60E/DsKlmV2VxeleV8m+FduE+2i1Wjh8+DBsywIFayt79do1qU43DkK0atj1JJnXCmweLiLAnvjP6J2VOqa8cSDj4Hwfes5zUPZ6eq6LH/3oR1hYWMCDDzxQ6j0QiXieB0IpLNue2DBIkQt5TWN1na0UEeEgQnqSageRJAlcYRRw6XDKu3JmjQKBEJ6KkwRRHMveEQa/H2TE/sqQNwrIEKNACJSlGW/hIMIgwObmJg4dPoyl5WUcO3Zs6vLbiv2hShk/Z1BKUZufR/fGDcRRhDhlzVdobhDUdR3VSgVdx4HneazUKFeKaBgGDMNAGIbwPA9RFCHkiVC6rrOYfxwj8H0Evi/LIsvEO4WBMDs7i0qlgitXrqBarSJJ0wONl1JAuuezKzgCAJT2WMvjTDiGYWBpaQntdhvbOzsIwxBXrlxBo9VCq9kcOfCJyVZ4CkQyXpL2S9gOKnmrVqtodzos/8B1ZbhhGGXK54qqFUSpmqZpE5VJJkmCV370IxBC8OQTT5SamPN9EiqVivSAiWs3rpGQbyI1xht7SjPT7P/y3p4Rm0qSBL7vIwgCOZlrlDK5bN6NswhKKTQAEVhOkKhaoLmcjbFJU6bAmfFCSY+jafZ4hsTnNGv4iPuTv57S6+P7uLG5iYWlJRxaXsb6+royDG5DlHHwOYRSitrcHDqbm0h49nJCmJSqdO+D1coHQYAwDOG6LmtwlInXi0GpyEgQUsuUUllKGQSB1E6wLKtUgxRCCA4fPowrly/j2NoaWy0dcGMVkl/ZZAb1nvW2MBpEYhxGGwwiFryxtcVWgVxXYn5uTk5kvbvYk5Yu2jItSOiSkrr5/1PKelZ0Okxbn1eeDEMmxQ05rz7PATBQ36BMAhoAnDt3Dpubm3juuedglei4GYUhOo4ja+Xr1WrP54tQClrGC8Q/13lDYlQZYXbSl4ZAnkyMPSkIF+RJ4hge/84INO4NMUuqGlJdBwlDtg1utE9KEscIwhBhEPQ0byoyCkS+S/5zONTjRVh/lxubm5hbWMDykSPKMLiNUcbB5xSq66jPzaGzsSGrGJI43vMi8DKoKm+A5Ps+LMuSq3Yp38q16YFeI8H3fYRh2BNbF78LI0F0ghw1YC0fPozzFy6g6zisPO8AqgyKkHsR0r8FA352IkgBFj/OJllmtiVXfbqOQ4uL6Ha72N7eZq2gr1xBo9HAzMyMHAxFXkRR3LnoWOXRZSo28mi6jlqlAod7hHRNGy2fO+J69zkGkO7lh+QG9jKr70uXLuHDDz7Aww8/jPn5+ZGv9zwPnueBENbDoV6rFeY1kIyxN+gohMt7oJFXZAiI//fubO8t4EZcxjgZdkWTOIbn+wgyyauapsHmnoKypDwEF6QpwiCARikMLoBUehtJgjAMEYRhj3DRQKNAPJ8RXpLbYgclj02+lj/nui62trcxMzcnDQPVYfH2Rd2ZzzFU11FfXISztYXI99mXNOdF0HUdlmXB8zw4joNGoyHfn9V1L/IkxEmCMAjgB4EsW0rSVA56acq6x4mEuUED36HFRWiUYnNzE8vLy3slXGwjB1KSmKVn60MmXvF8dsJIM6/tcS2DNUmybRubW1twXRedTgeO62Jubg5V2y6dOJg9vux9GJQzYFoWojhGEAToOo4Uxxm4/ZGhhXzOQVIsm1yCTruN1197DUeOHsXdd9899LVC6CcMQxAAlmnC5hn6A49UhMaAnlK6bGKerPrInLOQ7y4KCww7PipWzyXeE8cxCx9kjAJd12GX9LJloYTI3hWJqGShtLSqZBRF0muYPV/dMGDy73eR0VjkyRKIpko9pEy+e3d3F47r4tDyMhYOHVKGwR2AujufcyilqM/Pw+t04O/u7mXyxzEoz3iuVCrwecdGPwhgFTU7KhgoNEqh2TYsy+oZbCgXCQq4e1J4G3RdR6VS6TMSDMPA4qFDuHHjBg4vL8vBKuvS7xngD4jsOYoJs8w0QXKrxuxgSyjF/Pw8HMdhfSSiCFevXIFl22jxJLOi/RfuJ/eaYRNSpVJBzJPUHMdhrW4HbD8bWoiTGG9cP4PL3UtIUjbpvL/9Qc/rP9n9FP/14z9lHgQzwVxlFs8efgZ1Y3g73TiO8fIrr8C2bZw+dWqox0Ict2i3XK1WpTDWgJPoK/MUIl4iXDTSsCprhKaZRlNljQLPQ5CVFJ7AKBAKpD2Jjele/ocxYltFYQOAhYZMw2B5RwNc/DSTVFm47Yz3K3tNwijC1tYWiK5j9fhxLC0v4+jRoyqUcAegjIMvCHa9Dt004WxtsRUV9r7ElJC95ETXZbX7Y6zWCSHSm5DwXvKB78tJMwgC+L4PXdcRhqEMN2STrQ4vL+Ots2dl+V5+PXpzAg25fWYH4xJJez2TT45qtQrbsrC1vY2dnR24jgPHdVGxbbSaTdk+O7PBvnPOdsMctVolhLD8g3YbEc+CrwxxOYsV9v999nfwvYvfG3quF9sX8Z/b/x9SpNjABgDgP3/8n/HbX/lnIGTAoJ+mOHPmDBzHwVd/7ueGhjrCMESX5xcI41UYlNKbBPR5cIpWrZRX5IzbQbQQ4VUokcQJQFYChRmjwOCeunGNAkF+rwnfj6ZpxZ457skLgqAvbGCYJgzDGHosojSxr7IjvxsRHstcI8dxsL29jdbsLBaWlrC6ujpRl03FrUEZB18gdNNEfXER7s4OQt7NT6yOTdPsT04cBF85Jdn4O4dSCss0YZkm4iRB4PvQdB1xFCEIQziOA0IpXM+DbVmwKxWYhoHDhw/jzTffxNbWFhpl+7aXyIqfBsKDQcAG40Fu55Erf01Ds9VCpVplBoLrwvM8eb1bzebeAF+wSst2U8yWYvbEybPeD56gKFrmapQyT4UIg/CBX4RK4iTGf//sv4+8HjofNiLsTTbndy7gs85PsdooFrE5//HH+OSTT/DEE0+g0WzKiSQ7oSRg5Y2e7zOvFs+fEKWzPdei58IO73Cp6zqiIpd3dnsD7mk2n6BMuCHOrs4zrzd1HVbJSh4ALCcIwKiCVFGRpKG3n0IURQiDgIUwsmEDXYfJjYLRuSa50sRBx8DDGoRSWTWys70Nz/exfPQo5hYWcOzYsZHJsYrbC2UcfMGglKI2O4vAsuDu7PSsdk3LQshXO6ZpDl5RjFglCzS+6rNtW4YdRMw18H34nodutwvLslCr1VCt1bCxsYG1sippNylxEdhblVLsDZb5CWVY7F5IQxOwlruLCwsIfB/bu7vwXBeu68J1HFRrNTQbjYH5GbKenBCkQi47u8/c/jWe7+G5LluNU7qXJ5BmSvDAeigsV5fxSfvTPruLJU6Cr9opYsTwSYCYT181vYrFymLh+W9tbeGtN9/E+vo6VldX93I0Mj9F+WUcRSy/wLKksFMpRhiKuqZJD0IRfZMwN4BJiXyCRCT1BUFPtj4BC5llE32Hwg2CbM7NqLMPo4hJR3OvXRCGLFE4k89CuVfBNIyhuSd7hzFG3kX2d34dNjc3oRsGVtfXsby8jMOHD6swwh2IMg6+oJjVKqhhwN3aYgMyIbBMk03aQSCTE0tL7OYqG/LPibBDpVJhJZG+D8/zEAYBOt0uHMdBs9HAlWvXECUJhkSXi/ePvVjsgecmyF9GJC9yRKliHtOycGhxkRkJOzsyKdTpdlGr1dBqtQonFREXTsSx8BXboMnR5jkhURTJ/ANa9FpC8M27nsc/e/O3+zaVdRfr0EFAkGBvNf7Xj/81WFp/qWbg+3jllVfQarXwyCOPFB5fHMesoyK/jtVarTDvZSglPqearvdMmllS7gWTngIMv69JkiAKQwSZsl6Boevy8z7O9wfoDxuMIggChL6PUNPQzn7GCGGJhcOM/Oz++w9o5HtEfxPwR7fbxc7ODmbm53FoeRkrKytotVrjnZDitkGZc19gdMNAbWEBJg8hEEJQrdWgUYowDNHudErFVoG9yoZRgyHl4i6tZhML8/Msc59noNcbDcRRhAsffYQbN27AGaOHgzhKkvv7ICHZxxDX9iiXtGlZOHToEA4tLclJses4uHTpEra2tvqqGqQSnbg2YtU86Nrz/ANCKZI4hsNDSgUHiq8d/SoO14bLGOfDCrZm4/kT/1PB5lK8+tpriKIITz75ZKGhEwQB2p2OXKnXeUvxMoybQ5BP6JTHCS4BLXJMhnh/wjCE0+3KJkjCMNA1DVWuHFir1fZExUYcP50gF0IkOO7u7kqJZbENTddR4SGqSk4LYtAxyMTfYZ+hApI0BbgS6+bmJtrtNg6vrGBlbQ0nT55UhsEdjvIcfMGhlKI6MwPdNOHu7EDXNNTrdey22wh8H7sAK4UrOWgMUkUrQuM6C8KboBsGLpw/j2vXr6PRbMr8BIsrL1ZLDHYCkvmZoGBlNEWyiYIE6MkXkD0eSmBbFuylJdalbncXgeeh0+mg0+2iXquh2Wz29J3oqyXPJ+plj5HnH3Q6HURczKooBqxTHX/znl/F/3nmnxYeI4UmWzgL4+CvH/9raFn9E8G777yDq1ev4tlnnulTa0zTFK7nycRV0R9hrIZbJQ3XnuOnVOYfpGlGyGfItkRILArDnvADpZRl+Zd018v3ZcJPZc4gSRLp+REtmQGg67pIwUIX1VptrOPoCR2MY5xwD2HKDgx+GGJjYwO2bWP1xAkcPnwYS0tLKozwOUAZBwoALMyg8WoGM01Rr9fRbrcRBgG63S6qlQoopeNnfIv4eDpY6IcQAtM0cWhxEesnTuCdd95hRgAhciLzPA87OzvQDQMV22atp01ztCwx9laMB9WlMXseIsEPYIN6WS2DLJVKBZVKZc9I8H10ul1mJDQaqPJJvS/nIfOz6ExFKanLBZKE4ZXnZ4/+LP7w/f8HP+3+tO85AywXQhgGlmbjm3c93/e68+fP451338WDDzyApeXlnudEe2mZX2DbsHN9Aw4SjVI5uQ0yDOI4lnkE2cRCSgh0w4BlmqWTC6UeAvYSgIdNyCI/RRgDcS5sATAPQRrH0A0Ds83m6GS/rJGe/1kGbhTI8B2Xst7e2cHc4iIWl5awsrKCZtlkYsVtjzIOFBJN11Gbn4fXbgOdDtJaDZ1OB77ngRIiB6BxjASxkpauyyETNKUUx9bWcP78eVy7ehWPPf44q55wHLiuK7PAwyBAu91myXaZiodhXoWsct1B5Sb06CTwv7P/KyOpm0UYCY7jYGdnh+VntNvo7O4ChKA+rL3xgBwQy7KQ8lbAruMwwyyX/KgTDX/z3r+B33rjn/RtV4QUQm4c/LVj/wNmrJme13x28SLefPNN3HXXXbjn3nt7ngujCA7vplhWv6CsJPMoeu5FgdEmEwvDsMeoI+B5BDx+X+qzz71IBL3Z/oPeK4wB8cgbLJRS6IYBQ9eh6zpr6pWm0DVtuGHADZNRBsmw80jTFCRTXRKFIba2thBFEY6srWFhcRHHjh1TokafM9TdVPRAKUW11YJuWcDWFuIkgeu6cFxXrjSFm3xsT0JBOVr+3ZVKBWurq7hw4QIeeOghllTVaqHZaiGOIrieB8d1Efo+09sPQ3S7XabsxsvFTMOAbhiFXoV8bsLeoU1HiTG7as9PQNnQzDhejGq1imq1KhO+hA6A47ogmoZWvd4vXpPJAcnvy65UmJIlTzwl1WpvdQQheO7IV/CH7/8HXOxc7Hmvkck3MKmJ53NegytXruC1117D2toaHnnkEXlNRcfBIAik+NawMFH2fuzHMOgRPcoYiNmeIKLpUbjPxEJpAGMvB2fQsadpKj0DUU6GXBy3zg0BXdd7vBRpmqLrugiTZE/NcNixZH4vTdYoEPsF4HoetjY2YFWrOLK2hsNHjmBpaWm8bSvuCJRxoCjEtG3oi4sgfPB2HQfdbheUUqnEJtTrJkmqAlDoTTBME6urqzh/4QLOf/QR7rvvPvmcpuuo1+uo1+tSilZ4FERdt+O6coUlBnbx90jZXQx2yZc/KSJr9odtJzvxlemtAAC1Wg2VahWO48C/dAlRFGFnexvdTgdNfl3yHfOQWfFlqVYqSMFa53YdB/VaTU7UaZKAguBv3vur+M3XfyuzPZLxHIT4xvH/EfP2nHz+xo0bePnll7G0vIzTp07JcwyCAK7ryvMU3TsLjTd+vH0u8JL0VJIMSAQVE7PneQjDkBkFIqGPqwUaA4zLnu0AA3Nxij5rcSZvIF/hALDPt5ExBgZ9XkPuQQOAim33alvwfcuzHvf6Ed6UKveZjKKIJUB2u1g4dAgLi4tYW1tjypuKzyXKOFAMhOo6mgsLrD3z1avwfR+dTgeNen1vxSfKmSY1EvLuU0JgVyo4euQIPvzwQ5w8ebIwtiuSGavVKhNYiiJ4rouQy0C7YQjX86BnB1z+u6Zp0DRtqGdBILPXy54Xn5TSMfom9KyQh5QkAuz61Gs12dgpjmMkSYLt3V20Ox3U6nXUa7Xea5YNqWQqG2qVCjq8JK/T7aJer0MXkxIh+Mrhr+DfN/4DPm1/CgDQuG5lghQ6ofiljNdge3sbP/zLv8T8/DyefPJJEEoRx7GcgEXTpEHegj6jYAwK35H5XCVJgijjthchg4R/dimlUhhoZB4B2dMiGHakQqI8Eo8w7M8R4Ya28A6UTeLzfB9+GMpSRXZYZKS3YvhpEVmWmD2vOI5lG3LdMHBkdRVLXO1QhRE+36i7qxgKIQS12VmAUty4fBm+76PLE+N6OvLt10jI7M80DBw7fhyfffYZPvnkE5w4cWLoezRdR0XXUbFtxFEEX+QmcI+C53lMKEbXYfJ+92Ii0jQNGjcY9AKDYdJY7STJjyI+XVSNkEe45WvVKjzfR7vdRpwk2N3Zwe7ODuxKBfVqlQkJZVt151aV9VoNnW4XURSx+1qvs/vKk8/+l3v/Z/yj1/4xgN5kxK8f/zrmbdZRsdNu48UXX0S90cDTX/4yKKXMq+N5MkHT5j04+j4XJUtgi66VcH3nET0lRDJfkcaErmkApaVyCLIy2kC/AZkkCUs+jSJEcYw4SQpzGgiwFyooY4gUILwGcRTB4vka2Xs7LsOMgk6ng3angyiOYZom1u++G0dXVpQE8hcEZRwoSlHjgjyXP/0UYRSh026j0Wz2u1WnYCQYhoFqpYKl5WW8/8EHWF9flwleo9B0HVVdByoVaShEQSBXcEEUIfV9dnyUghYYBdJYoFQaD4PIryCzCY+TkG/+lN1PdjVM+cocAJrNJuqNBjrtNrrdLhOZ8jx4rsvactdqqOfyCrIrzVq1ik63izhJ0Ol2ZekqIQTPLD+NOWsW170bPfoGv3LXLwMAHMfBiy+9BNu28cwzz4BQik6nw6S1AWi8umSY2ua41ybf4CqfzJfkV+hg91TXddbCmhsEKZi7vM94yHgH8iWHcWbyj6MIkejmOOB4hZdKeCX2m9cS+D48rmBaRkthEKOMgk63yzwrUYRWq4VHT5/G4uLivo5dcWehjANFaex6HUfW13HpwgWWOd/pDFbbyxgJBOhZvY5CtJE+vr6OV374Q/z0pz/FysrK2AJHWUMh4r0dwiBAtj9BnCQ95WoaIdC4izdrMFAuO5z1NIgVpVjFim0cRMmkMDp6mi9hT/aXEoJms4lmsylLHx3XRRLH6LTbaLfbsEwTNe5tgLgfhACUol6rod3psNeL+5qmoITgl+7+ZfyLt/+F9BycaK1jobIA3/fx0ksvAQCeeeYZJEmC3XZbfh4qlQqsTNfJSSoPegwCXgYYZwyBSEhI596jcSNAPAZ99qQhkTM+Ex4WiHk5qngMureUUtallH82KDcs90OKXpW6kHdNDYKANfIas1dBNjkUwECjIE1TpEkCjVIcv/tuPPL440q34AsISQ+6+FvxucNzXVy6cAERb8MskpJGTf7ZmPKoFU+cJGjv7uLV115DGIb4+Z//+cLtT/LhzcagY74CBPYEixK+MhQTr8YHfppb+dFcWEJMCtm49kF9uRzHYe21LWugRkCSpiyRtNOB5/vy/4RSVCsVVGs12HzyTsGui1DF1AhBLWP4/ebLv4WfXH4Hh6pL+N+f+99gERN/8Rd/Add18TM/8zN7uRZpCsM0pS7GJOQ9BFmvQNEELTP7uUGgDTEG+BvYypmXLiZcV0A+kgQJ71lQBOX3WufGQN6Q3C+Deht0ul1sb28jBVCv14c3R9vbGIDBSa89RgHXfTA0DfVmE+snT2L12LH9nYzijkUZB4qJ8FwXP71wATFPjKpUq1KTfpSRIORqh0kOA2wCvHT5Ml577TU8++yzWDp0aOD2ZD15OqB97wiEkRBlJglB1mCQcMMgX84pVsYJX3mBEGiUgvCV5Ljej0GIbo6maaJaq/Vut+ArHUUROp0OnG4XkTBcCIHBlQlrvFohiiI5UQi1TAC4dv06fvDCC3jqySexvLyMF198Ebu7u3jiySeZcQJudPCEQ2EIjmx1zS4aOx6+Yo1FEh/PGchvgZLeMj+aua4C4WWRYR5xD3MGoON5AxUsRTiCaho07jnKG4jToMzWojjG1tYW2p0OqpUKWjMzww2SAQaGIO8pQJLA0HU0Wi1UKhWsHj+OpcPDZbQVn29UWEExEXalgiPr67j88ccIggDItXkeNkETYE+CFXshh/ygW6lUMD83h1arhXffe2+gcSATsjKD4dghCL4aFHI8QqUu5qvVKIqQZOLmCY81i9p4ktlOCpY4NuhYiaZBIwSErziFG5zw/xVdi77tiOdzK0I52eYy1zVdx8zMDGZmZuC6LjrdLlzHYSVq2STGWo1VMXAjotPpoFarSWOJEoJXXnkFW1tbOHXqFCulAytPrFYqPTkEhYZByppQCfVIcZ1Fdn/R/dJ44qCe8dDIzSHj8clO/PwxTL46yTxHCJGTv5Z5TJt8qKDs59P3fbi+D13XYQ+QmRbG2LDSWNHkqiP6pgijYHYWtWoVVNNw7MQJzM7Pj3lmis8byjhQTEylUsHS2hquXryIwPcRxzFqvHGToJQnQfSDz4UdCGEKeuvr63jzzTexub2NuZmZkcfVN1lmjqUsWREagZjQ4kxIQstMgHKSynkeerwZPNktxnDjiWoaSwrkXgcKZkRplIJkEijzyXeZE+g5/6yxIUpARYVCPomRaBos20YSRYBhwPE8xHyiff+DD7C1tYWHH34YrVaLJTxWKnsaCdnJXngCRJiGb2Podefnrmdi9wRAnMkBSIKAGRJDJv4iNG6IiWubEibbPaisdZqIUEH+npfxGiRpyhJGwxCValWGgjIblyEdua8cfUYBDx8Io4CAlS6fuOceNJQEsgIqrKCYAp7n4dpPfwqv0wHAxHqEJK90+aO8q1+Iy4hBbmdnBy+++CJqjQaeffrpfR1r0XHs5wswKH/B54mP+f0I97b8n1jpZVzwYkIUhkFhrDhJ4DoONE1DvdHoMwKEcZUVd0L2f7lkyjAM0e100OVJjIQ3KEriGLZto91u462zZ5GmKR588EEsLizAMk1QXWfnFMdsAs8aANlM/0yyJuX7p5TK36UXJXNdegyfEcOUCN2IbdLs32I/OcK8EbdPpFbD1LbI6DoONjY3kSQJ5ufnZZVCmaF7oFHQajGjgF8X3TBw8r77YJfJY1B8IVCeA8W+sW0bR48fx7VLl9Dd3mYrUdNEla9IxoVgb9IEgEq1iuPHjuHHP/kJtra3MVvCezBs24X7y/1eNixBKYXJu/MJ4jiGyXUWxOo2FW5vPnENoic+HsdIRHgiM9GKYwyCgClWGoa8VmJC7fOYZCZsWa+fN17SVLbr9njIIYoiXL1+HdevX0cKYG5+Hhql6LouXM/ru4aygiPj+dAIYaEUft496oeZ4yrSBgDQ4y0pO/GPQng4Jnlfj8ElKPrfFIiTBDu7u4iiCNVajd1rdiAD3+MHgWxWFgaBvM5FRgHSFLVmE8fvvnt4jwvFFw5lHCimgqZpWF5ZwW6jgRuXL7MWt1Ek1fr6Bs0xkgd1TcPK6io++PBDvPXWW3j22WelhPO0GBSKyBsOQO8EXYTGm+FoA4yAbJw8/1O44sXPotVhCsjVvXifXEnmVus9tfoZw0BIC4u/hS4BCJFtiIUi5s7WFgLXhUYITF2HwyWrTcuCZZqwLAsGr9qQoZDMZCk9FWJVnXsu68kQz+1n4i/FkO0K/Ye+uzfMABgS55+UFMDW9jbCIAChFM1ms7gqhZfjuq4Lz/OY90qEMQiBYRio1+t9RgHVdRxdXcWC6o2gKECFFRRTx/d9XL9yBe7ODtI0RTVf755B1u6PMBRSAB9//DFeffVV3H3yJB588MGe0MMBTSEjGWQ4JGmKIAxHusPLbD+brBfHsdSQ2N3ZQZwkrNJA0/YmvIJ8gz53d+Y1Wf2EFEDEV55BGOK9d9/F9u4uDi8vwzAM2JUKAJaAmPWA6IbBOmTy9suinLAnpCDO6QAm0nGJ4xhBHBcbALd6SOSGXrvdxtbWFsI4xsL8PCr82gN7jayEh0C0UxZYlsW6elar7LORJU1Rb7VwbH0d5phaCYovDso4UBwISZJgc2MDOzduIPZ9pnpYqw1dCWaT9ooG6BTAa6++iguffoqnnngCy8vLsnSQZlaft3riEQRRxPIL+EoU6J2M+756hICkKZNQzq7y+XNSRIi/r91uI44i1Op11jkQe+Wc2X0OgwAApUiTRHYnFD0Rfnz2LPwwxMMPPoiZ2VnohgGfl/6FUQSNUgS+jzBXbpimKfM+cEPBtqyBmf8pIaD8nAdScC55w0Pc+75PjTA6M5+plBtut8PQl/VCZY0mz/dx/fp1RHGMeqOBVrOJOI7h8nBO4Pvy9WmaSu0K27ZZOG/A9dR0HUdWV7EwoPJHoRAo40BxoHS7XWxcvQq/2wVJU1lPP4rshzI7zIVRhD/7sz9DEAR45pln0Gg0Ct/f009g4qPfHzFPVjyor5jjOAh8H5VqdaBnphDhceGhCz8I4Pu+DE+0d3dx9sc/hqHrePrpp6W8cL3RQJokaLfbMrehXquBUgrXdeH7PnzfZ7kWQI9Er2ma0rNgWdYtVdyLRQnqLR768gaBIIoiXLt+HUEYglKKSrXKPDlBwDwdhABJAqppzDvAjYKh5a9pisbsLNbW11VugaIUyjhQHDhhGGLjxg10t7cRBwFzPdv2WJN21quwubmJH/zgB1hYXMRjjz3WX9qVfV+ayonoIDLJh5Hwmv5pZsRnEaWHpmUNVcsTMf3sZJgmCevu5/vSENMpxebWFs6cOYO5uTk8/eUvIwVr100NA1Xblqv1TreLKAwBQlCtVGCKe5CmiLjnwfM8+LzElT215w2xLIu5vi2rL0RxkKRAj4LlTSPrKRoy5CZpiitXr2JnZwdBGKJWrTLtDG5E6LqOSqXSe81HoGkajh47hnnVG0ExBso4UNwUkiTBzs4Odjc3EXS70DUNlWp1YNLeKN7/4AO89dZbeOC++1jsdJzVECEyvHGQxoLIEUiAgZn4+yEIAjjdLnSecCbIGgPZ7HqAGwWeB8/394SbdB22ZeH8hQv4yblzWF1bw+lTp0A1jVWeBAFsy4KeucYpAKfblXkVNl+97r1gb1iJ4hie6zJjxPPYxJwV7BF6A1xXwhB9EQyjP16+T7ICTAdNmr0HuedEG+coihDyqpAgDNFut1lPjCRBk4eLTNNkBoHILSl9AClac3NYOX5ceQsUY6OMA8VNxXEcbG5swO90kHJRl2wZYFlSAH/5l3+Jq9eu4fTp05iZmWEJWzw+XTrpTWSlH2ApWso9CFP7qvFzjOMY7XYblFK0Wq2hb0m4UeDzjpRIUxiGAcuyoGsazpw5g08+/RT3338/7rvvPmlQbG9vM5d0o9GbVwB2rVzuvQC4SmK1uuelyGTGZwnDUMbNPd9nhlNmZZ2tqCCENcISfRN0TWNGA/99HBXDnnsxhnjSKFJgL+chYwwIKW7ROjz7yH4WCIAoSRB4HhzXRRxFmJ2bw9z8PCq2PZFSo67rOLy2hgXlLVBMiDIOFDedKIqwtbWFbruNoNMBJQS2ZcHkGv1lCcIQ3/ve92AYBh599FGZod3TuCdbIicS33hsfRBFJXeTIsoTATYBjBXnzh173uhJkwTbOzsghKDVag1UxhPxavG8oeuwbBuGYSDwfbz8yivY3NzEqVOnsLa2Jt8b8dbchBsfERd4AnpLOYMgQNdxAGCvH0PR9R1w7j5PaozCsKenQn51n096BLiaIpdXzrZlFi2Ss0qSQnwqjOMeqe1xEcYA+Dbl5M8NAdE1Mq/emNfO0DSNleRyEaqAh3hqtRpm5+Ym/tzNzM/j6Nqa8hYo9oUyDhS3hDRN0el00G63ETgOAscBBWDyGHTZcMONGzfwgxdewPHjx7G2tgZN11Gv1Ub2JhhUGVFUTin+Ryhlk8oYRkN2UpKliBlECEBO+mOW0m1vbyNNUyZlzK9ZmiTSTR34vtRDME0Ttm3LhNBOp4O/fOklBGGIL3/5y1hYWMgeGAsFZJo7ZY2DPGEUodvpIAUTLarVaqCDVrwlzy9N094Vd6Y5VhRFPb0YxLWTeQ38Pum8Z0W2nfaw88jvH3y7ony0J0QDyO6Ngz4LlBsuBg+TGCJ0Yhgg3CjodLuyUsSybbSazbG9BYQQtGZnsXz0KCpK5VAxBZRxoLilpGkKx3HQbrfhdToIHWdvIhtSApflJ++8g5+cO4dTp0+j3miwySnTbnhfxzfkuGX5ZCbRsc+w4G7sLDGvEphGd7/d3V3EcYx6rSYbPgVBwI6FT2omrxLIXsuNjQ388Ic/hGmaePbZZ1Gr1fq2LUolq9UqTMsaOakmSYJOp7NX3VCvj65M2cfwI3pciPi9/DvT2llef36tk7RYiTFvCAwyEpH7vzBKRLhDGAHCABhm5Pq+D8dxEMUxfM+DaVnFvROGII2CI0dQKbiHCsWkKONAcVuQpil838fu7i6cnR0ErsuMBF1n3oQheQlJmuLP//zP0el08OSTT8oJW6gz3mx6+hugOJyQNxgmIU0SbG9vw/U8OSmJSVDnssqWZfWt4C9evIjXX38dc7Oz+PLTT/e5n0XsfHtnB0hTNJtNUE0rteJORSUDf23prPoDGIYCbiilGeNAGg053YNBZhoZ4cESuRDjItQMkzRFGIbQeKOpRiaxdBjKU6A4aJRxoLjtCIIA7XYb7a0tBN2udFXbts2azhS8p+s4+P73v4/FxUXcd999MumsxvXobyWi1l8g3NwpAGQ6UpYhTRI56UVRtOeO5q5/kd1eZBSFYYhz587h/EcfYe3YMZw6dWpgCaHIN6CUosmTHUu749FbyWAYBhPmKVuZsp98AO76j9MUacZDkGKvjPFWimSlaYqu4yAMAhmmEE2mmo3GyL4blBC0ZmawdPQoqspToDhAlHGguG0R2fg7Gxvwu12Au/JNXiOfDxt89tlnePmVV7C+vo677roLIY9Liyz6abjxJyEFClsLC+MgyRkOPYqKvCohCAKZsIdMGCNJEsRRBLtSQXNIq91Lly7hzTNnEEYRHnroIZw4cWLo9XBdl7m6udEBlDcO5Da41oGgYtuwJpHrzazwJZmk06zCIAhhPSkGXO+brm+QIQxDVqbIcyUI9nJSavX6wH4hKQCNENRbLRxeWVFGgeKmoIwDxW2PiGVvXb8Ov9ORk6dpmjIrXcR2z1+4gDNnzmBxcRGPPvooiz/ziaI6YdnkVM4hTTHoqyaaJ2URJXABz36X0zgh0jugGwaSKELXcaDxxjxZaWZCCFzXxZtvvolLly5heXkZjz/++EDBpB5pZp7LUK3VZNhhmHEwKCkvjmM4rssEk7An4tPn2ci6+dFbDZHNARg2WIl8gkEmz1TLSccgTVPWrIpXI0jDjt/3yqDeI9wIbLRaWD56FLWSIQeFYhoo40BxxyCSF7euX4ezs9Pzf41SaDz+u7m1hR/96EeoVqt46qmnkKZpjxehUq0eXLe/IceeDDIOuMxyHMc9JX3ZREdD12FwgyCb5BbHMXZ3d/vKGdM0xYULF/D2uXPQCMGjjz+Oo0eP9jRj6hNISlOAUiRRhPbuLsBd2BRgQk7Z3ImMITFw0k73FBF934frOPJv4UUY+y5kzk8cv/h9mHbBrfIaBGEIx3GYNwPsPop7nSQJ6lzoSMLvOSEE9UYDyysryihQ3BKUcaC4I/E8DztbW3B3d+E5juw8KMrYut0uzp49iyiK8MQTT6BWq7EGQXyQvhVehIAbKAmfGKIkkX+DVz7I33ms3jBNGLo+NBa9s73NYta8BG53dxdvvPEGNjc3cez4cTz80ENDa97zRoKQZTZMU1YxpCih8jiiDDNOEriOw3IRwOr8q5XKRAl94phSAKkoaRyy76TAO3OQJGkKN+Mt0DQNpmnCc13EPAelXq/L7pUC0zQxMz+PucXFXsVJheImo4wDxR1PFIZoc1Gl0PNYKCFNEQYBzv74x2jv7uKBBx7AwsKCLPMDANu2p1byKBAegiSzOozjWPZYyGbOZ94ESikoV/wTZXFl6bTbCKMIlmXh448/xnvvvYdarYZTjz9eSiEv3yFShBQqtRosblSUMg4wOLyQJbuaBgBD5ISM3PrePoABeRxZQ4d7LtI0valeg/z5Wbwpkuu6LKmQUtmwCgBACJqtFuYWF9EcIGalUNxslHGg+Fzhuy68TodpJkQRgiDAW2+9hcuXL+PEiRNYXVtDFIbwfF8O3rZtS3XGwoE58z9ZptjzNJF5A6JUroisMp7GjQGh8IdhWeojVryu6+LKlSt477334Lou7r33Xtx7330T9a2I43gvpJANU2C6/SHEytrnPR4IpahUKkO9OcOMgqH7AljeRvbeilAEpieZHUURXG6cpmkKXddRrVYRhqH0GJi6jioX6bIrFeYlmJ+HodQMFbcZyjhQfC5JkoQZCd0uQt/HT86dw7vvvouV1VXcd//9iKMI7U4HMR/IRfOfqUjOErJnAPBcCMr/ToCBxsNQMqWPWWMl4N6RTz/+GDMzM/jSE08MrVro3WTaZwwVhRSAMY2DMVQeI55QKVb2pmEU5oQMS+gcRZxRUuwjUxkyKXEUSYnqlBCQNJWtqV3RmTJJYFsWarUaMwgWFlQugeK2RhkHis89YRDA63Tw3rlzePW11zA/P4+nnnoKhq7L1sJSHAdgfR5Ms7dHA4q1/bOToNDyp5QOnHCGJSaWhrvJL168iLfffhtxHOOuu+7CkcOHMTMzU1pPIB9OAJjiYpKrUgCm7znIkqap7BQpjseyLBbS2OfEXaRQOS1i3m0yCEOZ82BZFmzLAiFEtrVO0hQLi4s4vLKC1uzsLRHmUijGRRkHii8MSZLg/Acf4L9997uoVyp49LHHcIjH5IMgkEZCkiSglLIJyrL2PUEVHcekX7pup4MLFy7g408+ge95OHL0KB579FH4vo8kSdCo18fKV8gyKKQATGYcFHkmhhHFMRzHQeD7cp+GYcDiVRqTxOIPIhExaxQALOxj2TYzCihFEATwPQ+EUtRbLRxfX0djRNdMheJ2QxkHii8cGxsb+OM//mPs3LiB5YUF3HPPPVhZWQHlA7vrumwCTxIQSmHZ9lRWsYJxvQdpHOPylSu4cP48rl27Bt0wcGxtDcfX12UIocPDJ0Kbf+jWB7jSB4UUgIPxHGQ9MtlhKAxD1qmRT75IU3YfTBOmZQ2t3MhvX5SETgNhFPhBICWmTctChSccep4HPwhg2zZac3Nozs5ibm7ulit0KhSToIwDxRcSoQPww5dewsVPPsFss4l7T57E+vo6DMNAGIbMSOCVB5RSmKYJi68O90sZV7frOMxL8PHH8DwPc3NzWF9fx9GVFeg517TneXBdF4ZhsJbJOQMgBfaaPQ3ICbh06RI+vXgRn332GS6cP4+Pzp9Hp9MBADz7zDP49V//9ZHH/C9+93fx4osv4vTp0/iNv/f39vYvjidTQTDKs5DEMfwgQMClhsEfumHAtqyRHhLR4Go/pGmKiMtV+7ztdZok0ihIAfiehzCKUK3XMTM3h1qjgVqtdktVORWK/TJZgbFCcYdDCMGJEydw4sQJXLt2DS+//DJeOXMGZ8+dw93Hj+PkPfeg0WzKTPMkSeD7PjzPg67rsCyLrQgnHPxppo1wD0mCK1ev4sL587hy9So0TcPa2hrW19fRGuKaFloBsmQvd1yiIuBb3/oWvv3tb+Of/fN/jsXFRWlExFGEf/SP/zGQptjZ2Rk77CEm+lOnTuEvXngBZ8+eRRCG0HW9MD+DHeLwa0c1DZVKBbZtIwpD+EGAMAwRRRHaYSi1A0zT7PMmCGNoUpI4lt6LWIg/ccOkWqkg5j0SkiRhCoZzc6jW66jX68yAVEaB4g5HGQeKLzyHDh3CN77xDXzta1/Dq6++itdffRXvfvghjq2u4uTJk5ibm0MYhvKRJAm63S6rcODJi+MmmRFCmPIgnzA9x8Enn36K8+fPw3VdzLRaeOyxx7C6ulpKJEjTNNbQiZdTDjseQqmc7AAAPCEQacpEe9IU8/PzOHzkCH589ix7iXhzRvVQ/gt7nRwfefhh6KaJwPdx7u238dhjj/WoKU4CIYSJQZmmnLQDfh+Ex0RIaVOeFDpJnkGaJCykwftYCE8HIQQmb/oVRRE6/N63ZmfRnJtDrVZDLZfAqVDc6SjjQKHg1Ot1fPWrX8XP/MzP4K233sLLL7+M89//Po4cOoRDS0uoVauwbRu6YcDQNCSEIPB9+J4HTddZ2GFYbgJXbmy32+h0Otjd3cXOzg52Ox0Evg9N07C6soL1EycwOzs71rETQqDrOjNgggBapVKw++IJOk4SBEGAr371q7JpVavVwvXr1/Ebf//vs+0PeX/2bC3LwkMPPog333wTr7/xBh577DH2/D4NBAHVNJZXwUWufN6dUpw3wFpkU0J6hKVEWWm+fTXAyikDbnCkSYI4SZAkCXRKQXUdOm9XHfg+DMvC/NISGq2WNAomVXhUKG5n1KdaochhGAa+9KUv4fTp03j//ffxo5dfxo/few++57FJhxBohLC4cqUC2zRh8eY5lm2z1rtcEa/d6aDT6aC9u4t2pyNXtJqmodFooFGv49DiIhqtFg4tLu5LDEfkSgRBADtnHAybmEXnxL/y9a9Ppfb+8VOn8Oabb+LMG28g/dt/m4U0gKkZCGxT3GtjWaxrpe/LngXgDZZi/ncASI8HJUQaCEkcw/N91lCKv54QAsu2Wftr7o3Q+cPgfTlEPkHZxEiF4k5EGQcKxQAIIUxt8N57AbAs+p2dHezs7GB7exvb29vs960tfHbxIlzXBQWbCDUuhGRbFhqNBmZnZ3Hs+HFmEDQaqFQqe935sL/4uMA0TbiuizhJEEWRXNEOm5CTJJEr7onaKRdw6tQp/Ot//a+xvb2N8x99hLvuugvA9A0Egca9CQBkKaoIr4ifURQhCEP4PGcBPFShmybseh3VahX1RgM27/WgCY+DkLTm/9N1XeUTKL4QKONAoSiJYRhYWFjAwsJC4fNxHGNzcxPXrl1DHMeo1+tI4xiB5yF0XRAAOs9PSJMEoBQEAAUQj6EqOAjC2zkHQQDf93uTAQfgeR5S3uRpWu7x2ZkZ3HXiBD766CO88cYb0jgADs5AQEbPgFIKQikIITI3IQVQrdVgV6swbJvlJ1CKKvcEZA0C5RFQKJRxoFBMDU3TsLi4yKoAwGLZvu/LR+B5CLiWQKfdBuXZ9oZhQNc0xGna01J5EizTRBAErEW1KF0cQMJzDQCWKzBNHj91Ch999BFef+MN/Mqv/ErPc1M1EHi1RQJIj4kfBIijCFTTYFcqqM/MwOb5IpZlsV4aGQVMhULRjzIOFIoDQtd16LqOWq2GNE3lil48QteF73nodrtIRWfGbBKdpu01gyrwLBRNbpqug1CKJI4RhuHQDHqfVyZomjZ1oZ7Tp0/jW3/0R/js4kVcu35dKlHKY+fHnwKDjZgCrQaRGJlwQyCJY4RRxH5PU1i2jXqrhWqttpcHwg0CJVusUJRHGQcKxU2AELInxwwWgujxKvg+Il5CF3I9hTRJ9uLeug6NN3Hq6fmQ7RLJtRMMw4DPk+10wyhsSS2aBQFAZUq5BllWV1ZwaGkJ165exRtvvIG/8vWvy+fynRAJpSCZLokieZBwg0i0u47jGHEUyRbYBk8SrNVqsGwbJvcMiIfyDigUk6OMA4XiFqBpGqrVKqrVKlPhE+V4/OH7PjpbW3A7HZaBHwRSaIhSKo0FQilrzUyIbNFsGgZT7QsCdLtdVCsVOUkmSQICoOs4MPgkqhnGnos/46FIuTqkeJ8IBYjpVnQg7AsOcKPlsUcfxXf/9E/x2muv4eu/8Au9jav63pLKEsJsImHMwyPSg0AIdMPA/OIiGs0mMxAyD5UvoFBMB2UcKBS3GJFImHftR0tL6LTb6OzsMGXAMEQSxxB1DWmSIApDeEnCJvGM8QBgTywojpmULzci6rxc0dR15jXITvCZ0EXWMwEusAQMF0TKvBmnv/Ql/Nc//VO89957aLfbsG1bNkISpYbiJ9KUhVN0nQkZ6To0HhKhlMoQjcV1BqwxeiwoFIrxUcaBQnGbous6ZmZnMZMRRIp5LoGQEZbu9qzbPYqQRBGoYTCxpW4XXcdBHEUAgEajAd/3ESUJOp0OCCEyLAFC5N+B78O2LGl0iByFrFEgeiSI/wN7jZQOHTqEmZkZAMB777+Pe++/H7qmgRoGKws0DGh80qe58kFhDAijSYUHFIqbizIOFIo7CDF52rk8AZGklzcWtre30eHiS0mSoBtF+PDiRcwuLWFmcRGpaB+dJMwjkSRIeMMiYhjocuGnKI4BnjBJhAEhvBSUgor/8dU8oRRn3ngD71+4gJQQPPmVr6DRaPQYAJTnUKgSQoXi9kMZBwrF5wDCRZfyGfnNZlMmHorV99vnzmHh0CEcWVnpWfnnHzEheO/8eRBC8ODjj2Nlfb3HMMg/xD7E4//6p/8UP718GT//8z/fo3WgUChuf5RxoFB8jiGEoJKTUg7DEIZhjNQ2qNVq2NnZAcA0G8bt9/Cd73wHURThG9/4xngHrVAobjnKj6dQKKbOmTNn8OmnnwKAMg4UijsQZRwoFIqp85/+038CADz++ONYWVm5xUejUCjGRYUVFAoFAODFF1/Ehx9+KP++ceOG/P3DDz/E7//+7/e8/m/9rb81cFt/8id/AgD4xV/8xakeo0KhuDko40ChUAAAfu/3fg9/8Ad/UPjcSy+9hJdeeqnnf4OMg4sXL+LMmTMAVEhBobhTUcaBQvEF4ud+7ucAQOoPHATCa7C6uorHH3/8wPajUCgODpJOvXeqQqH4IvMLv/AL+N73voe/83f+Dn7nd37nVh+OQqGYAJWQqFAopsbu7i5+8IMfAFAhBYXiTkYZBwqFYmp897vfRRiGaDabMoShUCjuPFTOgUKhmBp/9md/hlarhV/8xV+EyRsnKRSKOw+Vc6BQKBQKhaIHFVZQKBQKhULRgzIOFAqFQqFQ9KCMA4VCoVAoFD0o40ChUCgUCkUPyjhQKBQKhULRgzIOFAqFQqFQ9KCMA4VCoVAoFD0o40ChUCgUCkUPyjhQKBQKhULRgzIOFAqFQqFQ9KCMA4VCoVAoFD0o40ChUCgUCkUPyjhQKBQKhULRgzIOFAqFQqFQ9KCMA4VCoVAoFD0o40ChUCgUCkUPyjhQKBQKhULRgzIOFAqFQqFQ9KCMA4VCoVAoFD0o40ChUCgUCkUPyjhQKBQKhULRgzIOFAqFQqFQ9KCMA4VCoVAoFD0o40ChUCgUCkUPyjhQKBQKhULRgzIOFAqFQqFQ9KCMA4VCoVAoFD0o40ChUCgUCkUPyjhQKBQKhULRgzIOFAqFQqFQ9KCMA4VCoVAoFD0o40ChUCgUCkUPyjhQKBQKhULRgzIOFAqFQqFQ9KCMA4VCoVAoFD0o40ChUCgUCkUPyjhQKBQKhULRgzIOFAqFQqFQ9KCMA4VCoVAoFD0o40ChUCgUCkUPyjhQKBQKhULRgzIOFAqFQqFQ9PD/A/sYf30wPVYxAAAAAElFTkSuQmCC", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cudaq.show(blochSphereList[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also show multiple Bloch spheres side by side - simply set the `nrows` and `ncols` in the call to `cudaq.show()` accordingly. Make sure to have more spaces than spheres in your list, else it will throw an error! Let us show two spheres in a row:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2024-08-12T15:07:13.626713Z", + "iopub.status.busy": "2024-08-12T15:07:13.626416Z", + "iopub.status.idle": "2024-08-12T15:07:13.876218Z", + "shell.execute_reply": "2024-08-12T15:07:13.875537Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cudaq.show(blochSphereList[:2], nrows=1, ncols=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can show them in a column too, if we want! Simply set the `nrows = 2` and `ncols = 1`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "execution": { + "iopub.execute_input": "2024-08-12T15:07:13.878727Z", + "iopub.status.busy": "2024-08-12T15:07:13.878439Z", + "iopub.status.idle": "2024-08-12T15:07:14.214092Z", + "shell.execute_reply": "2024-08-12T15:07:14.213405Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAALwAAAGFCAYAAABHS5l6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAADiO0lEQVR4nOz9eZQcZ3beCf9iyYzcM2svFAoLsZMECYIkCO6LZEkzLam1Wm1/0kiWbbVnxjPW2G3L57P/6KMZd8+MZH2SPLI99pEsS2OPj+WRRmJrsdzdanY39w0AARArsde+5R57xPfH+75RWVlZBZBNgABRzzk4VaiMjIyIvHHjvvc+97laHMcxG9jAXQL9kz6AuwmXL1/mC1/4Avv27SOfz9Pf38+hQ4f45V/+Zdrt9rrv/Zmf+Rk0TeNHfuRHbtHRfkoRb+BjwRe/+MUYiC9evNjz9RdffDEulUox0PPfnj174nPnzq25/9///d+PgTifz8e2bd+ks/j0Y8PD3wIcOXKEz33uc9TrdQqFAl/60pd49dVX+frXv87P/dzPAXD27Fm+//u/n0aj0XMf3/d934dlWbRaLb7+9a/fysP/dOGTvuM+LVjPwz/zzDMxEJumGb/66qurXv+lX/qlxNN/8YtfXPMzPvOZz8RA/PnPf/5jPPK7Cxse/ibjzTff5Nvf/jYAf+Nv/A2eeOKJVdt84Qtf4N577wXg13/91/F9v+e+PvvZzwLwla98hXgj1/CRsGHwNxl/+Id/mPz+sz/7sz230XWdn/7pnwagWq3yjW98o+d2P/iDP4imaUxNTfHWW2997Md6N2DD4G8yXn75ZQDy+TyPPPLImts999xzye+vvPJKz23GxsY4dOgQAC+++OLHeJR3DzYM/ibj1KlTAOzatQvTNNfcbt++fave0wsqrNkw+I+GDYO/iXAch/n5eQDGx8fX3bavr498Pg/A1atX19zuh37ohwA4fvw4Fy9e/JiO9O7BhsHfRHSmGAuFwnW3VwbfbDbX3Gb//v3s2LED2PDyHwUbBn8T4ThO8ns6nb7u9pZlAWDb9rrbbYQ1Hx0bBn8Tkclkkt89z7vu9q7rApDNZtfdToU13/rWt6hWqx/9AO9CbBj8TUSxWEx+Xy9MUWi1WsD1w5/Dhw+jaRpBEPD2229/Zwd5l2HD4G8iMpkMAwMDAFy7dm3dbZeWlhKD37Jly7rbvvzyy8RxTDqd5vDhwx/Pwd4l2DD4m4z77rsPgPPnzxMEwZrbnT59OvldVV3Xwh/90R8B8MILL6x4imzg+tgw+JuMp59+GhDhyjvvvLPmdt/85jeT35966ql19/mVr3wFWF68buDGsWHwNxk//MM/nPz+27/92z23iaKI3/3d3wWgUqnwwgsvrLm/I0eOcOXKFWDD4D8KNgz+JuOxxx7jmWeeAeC3fuu3eO2111Zt8yu/8iucOnUKwzD4+Z//+XUrsiqcOXjw4HWLWRtYjbWv7AY+Nvz6r/86Tz31FLZt873f+738w1/4BZ599lls2+b3fu/3+De//dvkcjkeeOAB/srnPsfM9DTDIyPo+mp/pHLvKjW5gQ+HDYP/CIjjGN/3CYIg+RdHEQMDA8xMTaFHEVEYEgUBURiS1XV+/Zd/mS/JVr7/4zd+g9/45/8cTdMAQTvYvWsX/+3f/JtMX73K9NWrXDx3jlKxiGGapFIpzHSaiYkJjh8/jqZp7Nq1iwsXLjAwMECpVEr2tYH1ocUbxOobRhzHtFotGo0GzXodx3HwXRfPdXn/1CnOnjvHC889RzabJQ5D0HVSqRRp08QwDGZmZvijP/kT3n73XeYXFjBNk7HRUZ5+6imeefJJ8vk86VSKZqsFmkY+m2Vmbo7pyUmazSbvHD3KSy+/TLFQ4K//1E8RxTEhoBsGQ8PDPP3MM+zbt2/D+NfBhsHfAHzfZ352lsX5eVqtFp7joGkahmFgGAa6pqHrOmEYEscxURQRhiEguO5oGinTJJvJkE6n0TRNGKWm4bku9UYDNI1KuYwGXL12jWsTE4J4FkUMDA5SKpf5P3/rt7h46RLf9eyz/PiP/iiu5+G4Lo7jsLS4SK1eJ5fP88CDD3Lg4EHK5TKpVGrjBujARkjTA3Ec47outm1TW1pifmYG13GI4xjdMMhls2QsCw0wTRPTNNFNE1PXk04kFfa4vi84NZqG63kEYUghlxMLU02j1WphGAZWJoPnOBw5coTp2VlS6TSbx8bYum0b6VSKtm1z6vRpgiDg4YMHyefzWNksxTAkjCJGhoep1+tMTU/z5muvcfL4cQ489BD9g4OUKxVKpRKlUgnDMD7Zi/sJY8PgO6CMvFmvY7da1JaWWKrVCIIALY7JZrPogO042LZNFIbEmkYEaHEsjF3TMHQ98aopeUNoQBiGRFFEtdEgY1lk0mk8zyOIIqYuXODM2bNYlsV9999PJpNB03XSqRQA77z7Lo1GAyud5qnHHyedThMjUppxHKNrGuHICPds387s7CzH3nuPd95+mz27d5MvFMgWChRLJfr6+hgYGFjB87mbcNcbfBiGtNtt2u021aUlaouLtBoN4Y19H8MwMA2DfKGQeEdd04jimEhmUeIoAiBSRh9FxNLgPc/DcRxiTSMMQ3zfJ4pj4eHjmEajwcTEBHa7zZYtW9i2bRuGrtN2HNKmScaySKdSvPXOO4RhyFNPPEEun4eOSDSKIsIowjQMUpZFsVBgZGiIl19+mbNnzvDAgw/Srtdp1WrUFheZmZ6mVC4zODhIpVK5tRf8E8ZdG8OHYUi9Xmd6epra4iKNep0oDLHSadKmiR8EaICVyVAsFISnNgwM6a01w8CQBq8hjN3zfYhjsZgMQwIZ0niOI366LkEc43serXab6dlZqo0GadNk29atDPT3U8xmSVkWbdsmDENy2aygFsuvSdc0NMNAQ6wPdF3H0HUi9VpHvO66Lq+99hrNZpPv/u7vhjim3mzSdhwymQyFSoVKpcLo6Ci5XO6uiPXvOoMPw5ClpSWmpqZYWlrCs21MEIaeTpPNZonCEE3XsVIpSqUSujSwZB9RRCS9uoLv+3i+nxi6Cm86L28Ux9itFm3X5crlyyxVq8RxzNDwMPlCgbRcYGYtKzG+bDZLNpNJnh4xLO+zY9+xvMkMwyCVSmHIGzQIAr72ta9RKBR4+umn0XWdIAio1es0Wi2K5TIlafh9fX3kcrmbdOVvD9w1Bh/HMYuLi1y9epVarQZhiB6G5DIZKuUy2VyOjGXh+T7NVosoiigVi6RkDN2JxLCDgED+VFkZBQ3QpPcF+QTwPMIw5PSZMyzOz7Nl2zYuXrrEQw8+iGkY+EGAaZrEcYztebieR6lQYGR4mEIuJ7JAUUQgQ5ggDJN1QRSGBPL1ThimSa1W44033uD+++5jz969yc0bhCGLS0vEmkahVKJcqVAul+nr61u32nsn49N5Vl2o1+tcuHBBGHoQkNI0ctksfX19FPN5NLnIDMOQtuw2ymWzK4w9RnpxzxPbdHpXgDjGTKUwUylSpomh6xjSiNutlvDOcczJEydot9s8eugQhq5z9dIl+isVDNMUN5F8uuiNBkQRruMwMzPDYipFpVymkM9jpVLEUUS3p3J8H1+uPTzfJ44iwiCgkM+zbds2Tp46RaFQYGhwEDOdxjAMBgcGaLVa1BYWqC0tMTA4iO/7FItFCoXCpy7M+VQbfBRFXLt2jUuXLhH7PgZQKhQYGhjAymTQ5ZepvlTHcYijCMMwkq6jIAxxXRdfhSkI7x0DaWngKh+vyRBG0zSIY+x2G9t10WS+/ciRI0RhyHPPPYduGNRkt1IqlSJfKNBsNpO4vLJ5M4uLizjy/WEUMbewwOLSEhWZYtS6QiZD0zDSaZAZnDCKCORNsHP3bhYWFzl1+jTZRx5BcxzSqRSWZVEsFkml01SXlpienKS6uMj41q14/f309fX1pDjcqfjUGrzjOJw9e5alhQX0MKSYyzG2aROZTIYoikTI0eG9wjDEcRyiOCaXyeA4Dq7nrYjVNU0jnU5TzOehI/WoUoMgFo5BENBqtwnCEDQNXdN479gxdE3j+e/+bjLZLLVqVaQVZVxumibFYpFms0kgM0epdJpUOk1J/r3RbBJGEQu1Gou1GoVCgUqphGmayTkp89cAU9cxLYuMZVEAHty/n1dfe416rUapXMaVYZNhGFiWRblcptFq4XseF86fZ3h4GN/zGBwa+tSEOJ+Os+jC3NwcFz74ALfVIgUMDw8zPDSEJtOJetdjOo5j2o6TxObdj/F0KkXaskiZZvJaHMeEHYauaRoxogHbtm1h6LpOJp3mtTfewPM8nn/hBbLZbJKa1DRNGKkMd3RdF56+0UjCq1w2C5pGuVymWCrRarWoNxr4QUCz0aBaq1HI5ynKRS/q2LuWZhqweWyMvkqFyYkJxsfHcV03Oed2uw0yy6MbBnocMz8/n6Rst27b9qkw+jv/DDrgeR5Xr15lYW4Or9kkm06zZfNmioVCYlTdmQ00Dcd1WVhcJPB9keNGFIxS6TTpVKr3I10ah8qchNKrh9KrW+k02UyGN958k0atxnPPPUehUCBGhElAsqDthKHrFAoFGs0mURRh2zbFQgFNUhgKhQKFfJ62bVOr17Hbber1OrV6nb5KhXKxmNx8yuNrySFr7Nu7lzfffJNWs0mlr48wivBcF1cuqA1dxwtDgiginUrh2DbXLl2i3Wqx9957ey7i7yR8aoIzz/P44IMPqM7N4bda9JXLbN+2jWKxuFzu73yDpuH7PrVajaWlpSSlVyoWKZfLFIpF0un0KmNXBg4kC1PP86jX68nToVAokM/lOHrsGNPT0zz++ONU+vrEx8YxoWz16y7zq30bhkEhn8eQ4ZFaSGvIXLuuk8vlGB4aon9gAEse50K1ysT0NG3bFpweeZNHcUwERMDmzZvJFwqcPXsW4hhD08hmMmJdIJ8S6XQaQ9ex221c+TRanJvj6Ntv076BZvTbGZ8Kg3cch/Nnz+I2mwSuy8jQEEODg+RyuRWLujiKBGHL96lWq9RlTOz5PulUisHBQTKZjKAGwOrQB4RnZ9lrqhBG0zTSMm+fTqV4/9QpLl26xKOPPMLI6Kh4vzToxMN3hQgqxAER0+fzeTSWqQwgYv5IpkLjOCaXzTIyMkKlVCJtGAS+z9TMDPMLCwSdKUr1dNM07rnnHq5du4bfJR2SSqUoFosU5Q1rmCZhEGDbtsg2tducOnEiWWzfibjjDd5xHC6cP09o2xAESQYmr4w9jkWZX9MIwpBarSYWf2GIruuk0mnyuRxWJiP4Kz0+IwbiLkOPgWarlXjfbDZLqVQiZZpMTk5y+tQp9u/fz5atW1fsK+ooWvUKaWC5sJROp7EyGQhDmu02bcXfkesQtZ7QdZ1yuczY6Cj5fJ6UYdCybSYmJgQTswvj4+PEcczk1NSKBbf88MTw+/r6RBU3ikQ6tt2m0Wxy+fx5ZqembvQruq1wR8fwibG32xiGQbFcxtB1cpmMWKDKzEUYhtjtNo7rJovFbDaLZVm4noen66RMs+diVi0Cta6KabPZxJeNH/l8PlENa7davPvOO2zZupW9e/aI98ubLopjURxCGHssC0grqqeIdKJKRRqGIW7YOKbdbmMUiysoDbqui9y9pmGYJkODg9iOw9LSEn4QsFCt0my1GBwcJC2fKNlsloGBAaYmJ9myZcvy+qbjvDVELULr76febOK4btIPoK5JGARsuo6kyO2GO9bDO47DB+fOEdi2aKQYGRGGoGlYliUYjLqO7fvU63Vc308Mva9SIZfNisKQ5xHDqsVYr/AFhDHWGw0xtCCOKRQKibFHUcQbb75JKp3m4MGDyxkTTUOTXjkIAlGkkvG7pmmiiKSoA/KGTPL5CD5PSlZgW+32irWIJrNBnchmMoyOjFApFklJesHU1NSKwWmbNm1idnZWPG06bvSEzx9FxFFENpMhl8lQzOeTG8axbeqNBtNTU8zNzHzEb/CTwR1p8FEUcfHCBULHIW0YjI+NEUkPpXjmkSSHtZrNhJ1YLpcFSUreGGEYJl66u6oKrApvgiCgXq8n1dCSXNgqnHr/fRaXlnjsscd630BApOL3G+Cld6ZH8/m88PqKX99j284bQdd1ypUKm0ZGsGTTycz8PAtLS0RRxNimTQRRxML8fHJTa/LaJscsF7yW5P6nUymsdDrh7TSbTS5fuEB9aem653K74I40+GtXrxK225iaxuaxMQzpxQBMw8CxbWq1Gp706vlslnKxKBo1OhaGarSMmUqJEEMuKru9OoAfBNQbjYSGWy6VViw6Z2dnOX3mDPffdx/9/f2rjlmFDKGK39cxeA2StCeIm0U3DPKS0Wjbdk9Rp+6QDMSTa2R4mGI+T0rXaTQazMzNkcvnKeRyTKpYXN4wvYhVpmmKc9V1wjgmm8kknJ92u82pkyfvGI3LO87gFxcWaC4uEkURw0NDIsaNY9B1EVu3WjTb7WWvXiqJZgdp6J0Gr7IlKdMUX7TMznQjCAIajQZRHJM2TUqFwoowwnNd3nrrLYaHh0Xc3oXOMCVp/buOh1+xQJY3SdqySFsWuq4LglsP3l+v49d1nYGBAfr7+zFNE9/zmJyepr+/n8XFxWQ7tebpphmDUDbWNC0JAfO5HFl5XV3X5eSxYywuLKx7TrcD7qhFq+M4zE9MEAYBlVKJrMzEqEd9o9nENE2y2Sw5mXVJFp0d+9HUglGm9pTxaT0MKAhDUQSKY1KmSUEWdoAk1ff2228TRRGPPPxwQh2O4jiJzVWY4MsUn6IoqHi8bdsiBOri9niSrBZGERnPQ9N1MpmMqNRGEe12m0I+D1EE6gbsqN52o1AokEqlWFhcFOQyoFavJ8fX+R71lInkAjpZ1GsagXwyptJpsU6ybcIg4PjRo9y7fz/DIyMf/su9RbhjDD4IAqYvXiTyPKxUiv5KJflSHNdNii0xUC6VMA1jzVhc8WiCMCRCePhenjGMIhodYUw2lyPwfQJp1GEQcG1igsmpKR48cADbdbGl5LVCpxF5nocfBKKa6boEQSBow0GA43krb0oQf3dddN9fkcJUXBsA1/dFY4quC0qApCRr8onXfV6WZTE6MsLC4iLFUokQuHjpElvGx1ctflUWSJ2DWmj7QZDclKZpkstmRbbL9zl5/DhxHCe1h9sNd4TBR1HE/MQEnuMQAiMDA4lXbrXbOI4jtFuCgKzMpXeW1HshDAJ0xOO7Ox8eyrxztVZLOp+ymQyNeh069u16HmdOn2ZgaIj+/v6ED6OrwpVcHCski8B0mlwut7zvdJpcJrMcQ3fwc3x5MyrDi6MIXXpcNwhoNpsiDdt5DnEsKMaS4GYYhojDJaNT13WGBgfRdZ2TJ06wuLREJptlaGCgp9EnC2IVFuo6fhAkjsI0zeT4PNfl5HvvEccxo5s23fB3fKtw2xt8FEV49TrNpSW8MGSor08UY4BGs5kMGsjl8ximKXpIXZf8Op07MSI3j66Tlvluz/MIgwBfNnW0222CIMAwjBVdQMqDGqbJBx98QBCGPPzQQ0kWpTv2XZFfl/F7PpfDkr2qGiI0sHo0VadSKXxZICt1qAQr4lqtXsf3fTTDIGWaRFLBIIpjNNkMEiOHMUhjVVRmQ7Izc9ksjm3jeh6z8/MMyxth9UUTNQSl0uB5HqmORbum62Sz2aQp5v3jxwFuO6O//Q3etqkuLBBGESnTpFgqEclQQy06i4WC0HsBAmnwlmUlj+BOxMhFaLtNs9nEkC1vSgEgiuOkYSNjWQlVQO/oYQUxT/XSxYvcd//9NyxZrWLlG+WXJwvXbuajpmEaBkXJoQ+jCEs2dADJ+iGU+jhhGIqYXdISXJZvxEKxiOO6otnE85iZm2NoYGAVM7Jt2xBFZDIZ4jhelSXSEMW0fC6XUKPPnDxJNpOhLHlEtwNu6yxN6Lr4tk2z0SCIIgb6+wnDkFpHLrxcKmFZlmjISKdJWxbIiqAykxgR6zabTZaWlgTLsNUilGlLNE00YciyfC6Xo1gsMjw0RD6XEz2iXUZ69OhRCoUCu3btuqFzUcYGN5aDV1iv40gRvTRNw+7IzesyjEmnUmQzGQr5PH3lsiiSySKWSsPm83larRb5XA7fcWg2m1ybmkrG78BypxdAKZ9P6AbdbY0gPH0unxfZoDDkxPHjKwpenzRuWw8fhSGBpL6GcUw6lSJjWdRqNaI4FszGQgFD5oORC7S8jI1932dhcZFUKpU0VccsG5BhGGSyWcrlMhk1TEw2gJiGQbFYXE55duHipUssLC7y9FNPreutVzRwy/CiV2V0LXRy79dCVi4YVRN5urvg1cGY1HVdOAVZLIvjmMViEc91SVkW5UqFupQQvHT1KkMDA6RME8/30XUdy7LEWskwII7FAryb8SmPO5/N0my3sSXh7IGHHrqhwW43G7elh4+iiLDZJJbVvCAMKRWL1BuNpDuos/DTmYZTPJRGo0GtVqNWrSYqBBkpudFfqZDJZEjJ/lMQXsyWoUxOKoNpsltJ61h8up7HiePHhayGHGdzI7iRgtMqyKcP63j5Tu6QbdtJB1UUx4SKIgwr5P2Wd68la520aTLQ38/oyAhWKkUURczMzjK3tERT8pAUP0lds1DyghQ6F9zoOgXp6ZcWF7l44cIqpYdPArenwcveUlXGT5mmKLLIXHi5VBJeUl7cKIqwHYdqrUZd6stkc7nlXlP5nkIul3hA9eWoL7EpQ6CMZSXcGGBFwUrXNM6cPk0cx+x/4IGehZ81z2mdpo+1oHX8XM/Lpy0L3TDEYtu2lxmQN1CYsmStwnEc0XGVzzM+Pk4hlyOKhVBULOkFruNQUyJVUjV51a3YdXPmsll0XefalStM3wYMy9supAldl9BxIIqEdw8CocYrmYOlUklsKDMVbdsWTL4O75FOp0XjRxTRaDYhjqnJHtB0KrXCUDVIuotM01w3u2M7DhcvXWLfvn1kMxmxcOsKO9ZKh4YfcsHaDbVfJeun/ob04BnLIggCPNdNGkJ6IQmTJGlMUaIdGbMrdYZ8Po/n+0SyMcZKp/GDILmZbKmXmUqlkjbEVR5cOol8Nkuj1eKDc+colkqf6Fyq28rDh2FIKCuRrqwwup4nhEt1nWKxKBiHYUij1WKpWsV1XWL5peRyOfoqFQqFAqZs0SuXyyIWRxh2s9VKsjKalLRThZR8obBu+HD69GlM02TXzp3iD13hQRICSSpwx4uJh++kFKjMUCdTUlVvO0WX1M8wihIDjzv2DWIBm5Ln6XYVv7qh+lZjWRMAcOV1aDYaeJ6HruuMDA2Ry+eJooh6s7ncOyszQlEUJT22nusm57jis2QKN5vJ4EqGq+IwfRK4rTx87LrJ4rNt26LkLtmP5WJRaDG2WriOQyi3S6dSpKWBr4Ck5JqGQblYpGXbuLJ3syVz7HqHIRYKhXXDjVarxYWLF3lg//7rNjMrPnnHH5ISfednaLCyYEQXeatjP+tla1RhKJPJELRaSVr2ek8TXdeJNY1UOk290aAsx2YaMqdumibpdJrZuTk8z2OpVmOgrw8zmyWWvCW1IG7JRph0Or1Cols9+SzLIvB9FubmmJ2dZdOmTZ+I/Mdt4+HDMBShjERNeu9cLkchn8d2HBbl3wAy6TRl+XjsNsA4jlfwYjRNo5DLiayO9EztdpuFpSVczxOpuus0J58+fRorneaee+657rmsKj5B4vFv5pesMiiaJHRdD2EY0mq3SaVSuI4jtDQtK3lCgjDg/v5+DMRNX5PVZsMwSKfT5LJZQRmW6meO69JU/QKwYtGtGuSnrl0TolifAG4bDx/bdlJoqdVquLI6WC6VaLXbItOC4L1kcznBcOyhvrXKu3YglUpRSaXQNY3FpaVEnk4Zh5VO9/TejUaDy5cu8eCBAzckVdG9wOxcX3xUg086uNbx9CC9vOxQ6uXlE916102yLCpVWiwWex5fLpslLJepSXUEU47hAXEjZ+SN5kmdm0jShlOpFJlMJtmnygrVFhdZXFwkm83ectnu28LgwzAklHFj0mQRBIl+ehTHooqntFcktA5iE7AcA1/HKFRlMkqlKOTzqAEIrusKyWkpz6FSiKdPnyaTzbJ9+/YbO6Eug/9OF6ywzGnp/XHLn5eSamixbBRRjeyBrE10KqihaVipFCkpRbLe8RWLRYIwpNlqsbC4yODAQEI3UNkuy7JIp9M48lqqOViZTCb53kzDIG1ZLM3PUywWE9rxrcJtYfCRHCGDLOs3pYcalBIbGdmUvd6F6RREWg9BGOLIyl+pWKSvUiGQrERfTugIpBKBYRi4rsvlK1c4ePDgihy6ypD4QYDjOEKpzHVxHYe2beM6Do70on7H4DMQN0AoBVijOOab3/ymIGAZBmYH61Hd0CnTJF8oYKXTZDIZ0XBuWViZTE+DyWQy+J5Hs9USzkQudhU6i0i6rovJJTfwPVXKZXGtHIfFpSVBGZaLX3UMmiZkP1KmSdtxiMJQqB74Plnp7TOZDLVqlXa7jW3bt1Sx+BM3+CgMiSU1tt1uU280BCVW8jLKpRLmevG1DGGux45UaLXbRIguJ5WhME2TgmkS53J4niemckiDPH36NGlpVKdPn8a2bdrtNs1Gg4ZUGe4WPbIsKzFMy7JIpdNEUtjIsiwxF0rX8TyPk6dOsX37dtLptCB+dSgCh2EoaLeeR3t2NpnnBCTN4RpgptPks1kKhQLZXE7oYkp6QRRFZGRoY0pvruJ8BU3Xb2gxp2ka/X19zM3NYXsejm1TrlSIZMq4E6ZpUsznk2MOgoCmpDAYhkHGspiZmBBy4NnsLfPyn7jBq8yMHwTUajVs207Civ7+/utfCBnC6LKjiK6m5E7Y8jGr6L7d2ykF4Wq1ysLCAkuLi8zJjqC3334bIHnalCoVhkZGkjg0m82KCq1cI3Qed1PqNXbHrNVqlZOnTrF169aekzgiWT8A4V1jRHeVI3VqbMfBkdmslkzTTkxOJupnOqKwVOoYddPX17fqmiYShJIjsx4Mw6BSqeDOzRFEEXa7TV42xHdDad2bhkFbzshqtlrJkIeapDG0223yckF7s/GJG3wkla3m5+dF/lfTsDIZcoXCDXns7g7+2DCE0XchlF8OMkRSXflLS0ssLCywuLjIwvx8QsLKy883dJ2DBw9SLBQSY/WDIPHGnXAch0iGS5quJ7SEVrudFM6SJ5GmJYQsTy4ik+KVzLWHYSjSfZIDH6lcPJCyLFKWRalcFrn5KMKQvae+7+O028wvLAijsm3OnjmDHwRCmbhSoX9ggMH+fvoHBpK0piaPt1tjXl3nGLEAV/UN23FotFpCj2etp7AsThV0nZbsjGq328JJyNDGsiwxP+sWpCk/UYOPgoAoCBJjN00TK5Oh1W4LSYgb8e5d0CCZr9Tp7dsy/HA9j8WFBaYmJ6nW66KhwjDoK5cZ37qVQdn7aRgGf/qnf8rOHTvYvm3b6mOX+1Khh6LiIr1rHEWEAGGIJ43ZlBrwCio8UQ0sq08vJpI03M60phqTaUjKstaRBQHx9CoVi1QqFVoy+1UsFqnX6+LGlud//ty5JDTSdZ3JsTGGh4d7p1W7boJiocCSzHQtVatJfL4WdF0X3HvXxXddHJkgaNbrDA4N0Wq1bkkF9hM1+NBxqFWrOLaNbhgMDg2JixjHgub7EZEUPSTfZmZ2lkuXLiVquErCYteuXYyNjVGpVDC6vuSLly7heR47VVW1C7qur5bikAWmRNNRtgK6nkcciymAKtYHkhSnKvB0HrvaLpAtgaViMRnc0G18nX2znUil0xiOgy8Xzmp0pco2tVot3nrrLaGtGUW8/vrrYsjx0BCbRkcZGRkhtQ7DsVIqJQvzRqNBuVxec1vFR8pKXX7XcfCiSByb7wuKcj5/0738J2bwcRzTWFykaduiq76/X/A1ZHPxd6RSG8fMzc1x7do1JicnaUu6wujYGAcOHKAkvyjVRLHq7cD58+fZNDa2bmzZvVBW2Yrk5jGMJAWKpomG6w6oZuhcNtuTwxNGEa5kKaoY+cNMKNI0jZRlEcoqc2eHkuu6vPnmmzSbTbK5HCMjI+zcuZOpqSkmr13jjTffBE1jcGCAsbExtmzZsipnbsjrZ9s2jVYryR6tcTBitGYUJZmldrtNJLVxRjdtStKoNxOfmMFX5+dxZHyaLxTIyfawKIrQJP99TXTxVNT/Pdfl8uXLXLp4kUazST6fZ3TTJsrlMpW+Piqy8duVj9S1TGd+fp5qrcb+Bx5Y9xx6MgXXKDp9J1mIFc3dmrZ6Yb7OTWClUkmWRCkkNxoNXn31VaIo4tlnn+X1119PxFt37trFjh07cF2XiclJpiYnOXniBCdOnGBs0ybuuecehlTYIz22yvNXa7W1WwTFwaPkStLpNJ6sC8zNzNA/MHBLUpSfiME3Gw38VgvX88jmchRyObGIU8JIsin4RhBLb37pwgWuTU4CML55Mw89/DD9/f3UazWCMCSfzS6PuJGhQa/FGQjvXiqVGB4aWvezO8MTdSzdZv1h2/q6Tq7352orVcZ63WgKumEIo5fpzWazyeuvv04+n+fJJ58kk8ngeh66YSwT3mTiYPv27Wzbto3A97l85QqXLl7k26+8QiGf557t2xkcHkbXNCqlEtVqFU9m2vrWaelT10wxPGMZ1kxcvcq2e+4hiqKbGtbccoMPgoBWrUbgOKL7Rk7XIBYtcJHMNqwJxYGPYy5dusSZM2doNBoUCgX233+/GNUu40673U4ESTvXBMmk7O6qbCy0GycnJzlw4MB1vfL1jF0dJ3y8HJru2U7reXgQfHnP97l8+TKnT59meGiIxx57DN00CaMIv6shW0HXdcIgwEyl2LlzJzt37GBhcZGLFy/y/vvvE7//PkNDQ+zZs4dKXx/zCws0ZYqxV3eTEqfVWW7UyWazRO02S4uL9A8OYtv2TU1R3nKDbzQaaEFABEnlsJtT3s0gTCAXg1euXuX9U6dotVpsGh3loYceYnBwcIXxxlEkhpSpxWK38cp9rYjBNY0LFy+iGwZbbkAVt9vD90JCC/4IIU0nBWDlB6/t0XvBNE0uXrzI+fPnGd+yhYcPHkwaaNQiu5fBgzD6Ts8/MDDAwMAA/oMP8sH581y6coVvf+tbjI+Ps2lsDEPXqdbrDA8OrtpXp3ePOkK9bCaD43kszM9TqVQ+PQbveR52swmelzRGJ1Om42XJ5l6mESM0JU+dOkW92WTz2BhPPP44hY4JH51I+lNNc2UHE8vG18tkrl25wratW3tmYFbdNDdgeB+Lh+9xs3QeT68j6Gx5PPLuu1y5coWdu3axfdu2FceSaHKusWbquWZAZIC2bNvGyKZNLMzNcfb8ea5NTjI0OMjI2BjFQkEU97rPQ9YYNMMg7mhqz1oWjXqdpaUlhoeHP1wr5IfALTX4er2OEUWEMu/b6d0TGmkPw5qZnubEiRNUq1VGRkd59NAh+mRlMuxhcFEU4UglsmyvRVDnk4DlG2x+fp62bff07r2eEOJHvDrE6DqWnu+/AazlAFSKL+kh7WKNqvf5vs/rr7/O4uIihx59lEKxmAw1Vrz8oGPd1BMy59+rnVGJQm3dvp3tO3Zw6eJFTp89y9z8PLMzMzz80EMrnI1aMyUTBzscRsayaC0uiorx0pJ4Yt8E3DKD9zwPz3HA88RQ3E7vDsthDctfsOd5vPfee1y5coX+/n6efe45wdLrQC9ja9t2ktrsle1JFMHkI119+VeuXiUnhwVcF5q2gsGoqLtJmNPxd1XYuVGoWFd1OvUKnVTjhWr7W3UN2m1eeeUVPM/j6aefZkAOII48D9/zMKT3VcWvNdOJ6hx7Gbz01kq9befOnYyPj3Pi5EmuTU7y1a99jYMPPcTmzZuTa6aMXe1XHbdhGGQzGRZlWHPHG7zrumgdWZHEu3csHBO+t6YxNTXFkSNHCIKAgw8/zLatW2+IahCGIZ6M3ddLcSltFWXwQRRx7epVduzY8aHPLe4y6O7cvPKSyf+XXxSNE9J4V7y3I8RLPHkHNE3rKf4KsLS0xGuvvUbKNJPpgSCaObwgwPP9JKfeloKuGTmIuSdkDr3by0ddzgoEcW737t30Dwxw8dIlXn/jDcbHx3nowAHSUlt+LWSyWeYXFpL8/M3I1txSg1dldw0RA/byGkEQcOn0aebm5hgdHeXgwYOrY8FOdO3DcRwiRGZivWYNdTFVyDEzPY3n+ze0WFXoroquPrQ4Ob5O+mzHDkSKlPWZnte70eOOGHtqaoq33nqLSqXC448/viJbkjJNdCCIIoIgwDTNRLl4XUYqq738iqaWrnCtUCjQajbZvXMnzdFRzp09y3/5L/+FBw8cWPb28ry0DsKaGmahZsMWehQFv1Pckha/KIqE1/U8DF0MEku++I6LdfXyZY4cPcrs7Cy7d+/m8GOPrW/sXe+PIzFzlDhe9xENJIKn6mJfvXqVSrn8kfgca/mspNyv9RZfUuKoa+94jSxNx986w6fz58/z+uuvs2nTJp5++unVqUFN9K/qup7UPBTb8broOocV0tpdx6drGqVSCU3XKRSLvPDCC5T7+njjzTd5++23VymWqT1pCH2cdqt109TKbomH9zxPzCeVj/6Uaa7yzFOTk3xw4QI6oKVSfHD+PBc++ICh4WFGR0cZHR0VchBd6LzUrhxa1tmCthZUHB9FEV4QMDk1xX333vuRzm+tx3RnjNsZj3e/p7PntdN4OsOcbhqD1vkzjjn23ntcuHCBPXv2cP/99695rGnTTJTK4kyGtm2vH86sAbVuWGsxns3laLZaOFLr84nHH+fKlSu8e+QItm3z+OOPJ9+R0eHl06kUdqslhqfdBNwSgw/DkEh6FE16mU6vdeGDDzh69CjDIyNsGhsjnU5TyOWYmplhanKSo0ePAqJDaUQaf//AAEZnxTGOk0lz1/PuQDKLNYoiJq9dIwyCDxXOKAPujLV7nbc6Z+KVOf9enPRVn9FNU+jeQBMTOV5//XWmZ2Y4ePAg9+zYsfy+HsdlSl1JX856bbfbPUf09IKSIYnimFj2GK8VZ6up4e7iIm05TXzr1q3kcjlee/11XnrpJZ56+mly2WySm9cQ6dFGq5XMpf24ccti+DAM0SGRsAMgjjlx8iRnzpxh965d7Ny1i7m5OaIwpFQuUyyV2LN7N57vMzszw/TMDFeuXuXcuXOYpsnw8DAjIyMMDQ2hG0Yye/VGmJaa1EcMo4jLV68yPDLSs6E48cw9DLLTW69nsN+J+BKsndJ0bZtvvfwyzUaDJ598kpGRkZ4hUne+PiVpyp6UF8yNj9/wMambN5TrhrXOTfFl1FhN23Eo5PMMDA7y3HPP8eorr/DNl17iySeeoFypCMmQMEwyZu072cMDoklbSjsoz3PkyBEuXLzIgQcfZNeuXbieh5rMoYpRaGLC9fjmzYxv3izGtFSrTE9PMz0zw9EjRwRXplCgUqkwNjZGuVy+bt7bkNkg13WZm53loYceAkjmuHZizeZp1n+sr8q8fFisE8PXq1VefuUVgijimeeeo7IONXeFx5e0ZtfzcBwHLwh61yrWgsqoSQ/fS0xViUrpuk4ul6PRaCyP50Fw859//nlefe01vvmtb/HMM89Q6e9fcQPdrEzNLTF4X6qDYRhJNuD8uXNcuHiRRx99lG1yWrXRkTlZZXgdGZFKpUKlUmHfvn24nsfExARXrl5lcnKSK1eukE6nGRkZYWRkRIiDdnnuOBYTMmJgbn6eIAyFd+TDFYiuRy34johjdBSeuo5pdmaGN958k1w2yzOHD6+qJK8J6Z1Nw0DXNNGJFceiQV593g2cv6L5KjWJ5HhZ3ShSyOeTIc6e5yXfv5XJ8Owzz/Dtl1/m9ddf5/nnn0+eCJom+PLqif1x4pYtWkF4A13m2N977z327t2bGDt0yNDFgm667sJTfnlWOs3Q0BB5KZ0d+D4zMzPMzMzwzjvvANDf18ewvAH6+vqSJ4eu61QXFymXyx/Oy3Udw1r4TkOaXvu+fOkSR44cYXh4mEOPPbbic24YmiZSknKqdrFUWlXVvd4eQ6mrqcu2xUQqsAuGYZDJZLBtm5ZtU+74Tg3T5PHHH+cb3/gGb7z+Os8880yyD9U083Hjlhi83nHg9VqNN998k9HRUe6/776V22la0vcZhuG6fZLqZ2dHUS6bJVUqMTAwwH333Ydj2yL0mZ7m3LlznHr/fdKWJTz/6Ci5XI65+fkPtVjtRryO0X+nXPjkhpEVyVPvv8/pM2e45557eOjAATTJZuxFr7geUqkUbdlQ3TkppVe6sXvvUSSGvCnG4/Uav/O5HI6UPil2jfzMZDI88fjjfOtb3+KdI0fYv38/aGIq4x1r8Fq83BH/8quvks1kOHToUE9DUI+0XtMlesHzffHoM4wVN4hqE9y6bRtbt20jjiIWl5aSG+DqlStEcZwoj1Wr1RuK/W8EquXO932hcyPHY3a+HsusEsiGFFniV/QE1R8Qyha4o0ePcm1igv3797N79+51iWM3AtM0hYJAPk8kr1+v80jQURVX0w/jGzB2EEZtmiZeENC27VWdX5W+Pg4+/DBvv/UW2WyWfkkrcGz7xsO1G8RNN/g4jollVe/axAR2u833fM/3rOm9VbXN9bwbool6riuUDmTZei2voOl6Qm29//77sW2bd959l8nJSaamppiYmCCTyTA6MiLCn+HhNfs5I0nAioIgEXaNpJF3HkNTxsiq4XrVsSvVArmA7IbdbuN4HseOHqXRbLL//vsZGRmh2Wyi5PGSp4BhJAvxG4GmabRbLYaGhwmCgPT12IlqISq9r1oL3ChyuRx+vb5i8dqJLVu2sLiwwAcXLlAoFikUCjQbDco95Eu+E9x0g1feLY4irly+zLZt29YtGafTaQyuL/kMImTwfT8RVlK57hXck7UKI9ksruMwPDzMvn37iMKQ6ZkZZqanuXT5Mrqm0T8wwPDQEANDQ4lGvVILEx8hJmv3usk0ZBlbZkXUkys5Gk1LKqEpOatJUWfV/jzf58zp04JPdPAg5XI5+UyF7pCmU7lMDYTotYbwPA/XdQWDMgjWT+Wq45JM1yCKBH3jBnQ2FfK5HPVGg1AuXns1iOzeu5ersg953759yRPw48RNN3glfDQxOYmm62zZskUo9q7hPdPpNLqUuFsPcRwLDfk4xpRGlcTMkLAN5carDN9xHJYWF9l7771o0rgHh4bYt28f9XqdmelpZufmOHX6NOH775PJZBjo7xdiRv39icycKWeVKo+rDBuWw41S5/TuzmsjPXwmk1lFdFtcWOD48eOkUymee+YZiuVyQjRLCGdRhGcYaFJLP0bwZLp1eXRdF+Mm5bhKQ9ep1WrEiBShHwQ9r1GnTg7qmsaxWLDKirbW8ff1YJgmltSddFx3lcGrMHDr1q2c/+ADtm3duj7t4iPilnh4u93m2tWr7Ny9G9M0sW1bzCjtYQSWZYlqXhSt6QlUyd6VBrNW6NHpTbu/jtmZGWKgf2AA1/OoVqvL+i66zujYGKNjY8nonYWFBebn5picnMTQdQaHhhgeHhYZoh6P6KTKyodftE5cu8bbb79NsVTigQceSMbda4axivyUDkNC6Z0jKQ6lJoVHQZD87nkennyPruvMz8+jI0KNWKooK7JdwvHpcdxqVKiu65iGQSAFrTrDq7VgZTKJ0CpdnCXf94miiPHxcS5fvszFixd54MCBD3XdbgS3xMNfvXqVlGWxb98+2nICh+M4QgOxA4p3kkqlcKUaV6fBq1BFccHV7FE1urFX0UihsyrqBwFXJyYoFAriESulQTLyZjNNk5QcwGuYJgMDA4kufLPRSIpeJ44fJwhDstlsQnkYGhxcMf3vwxh7HMecO3eOEydOML55M7t2717xxOjxhhVFLfWEMVdsIjyyWjwHsm+4WquRLxRwlaJBFImhECouX+MzQ9UhJbfTNY1Ieni1Xulp+PHytBGl3dl5g7meBzLTtnPXLk6fOkWj0bjha3ejuCUefmFxkdGRkUTbvdFo4DoOactaOXVDXqhUOo0u1XeLHS18nRdSyT4b8nENwjP3ShEqI/ckaSqKYxYWFhgaGsI0TTHjtWNY2npGWigW2VUssmv3bjG9emaGqakppqemuPDBB+iGwfDQEINDQxTy+RumuMZRxNFjx7h48SL79u4VoZX6wtc6ng7K8ZqLdU3D7KD/qjVAtVqlUqmIRaicPA5i8ZuW0w17ZW7UuKDkmnd91orWw47vLYZkamIs576qfbieRyxTnOlUipGREU6fPs3ExASPHDp0Q9fvRnHTDb5eq2G32wwPDwOCDWeaplAvaLUoFAqCT93xhVnpNDpi4Zp49a79qgxH5xOg+4uP4hjXcZJ5UQq+XLCNjo4yODBArV4XT5eOJg2N5Rz7WjeAaRhs2rSJ4eFhDhw4QKPRSBa+J0+eJIoi8rkcY2NjjI6OMjA42HOsThAEvPb668zMzPDwww+zffv2FbqV19OFX6/iG3e8rs4rCAJazSb79u5NFsKqlhGFIU4Y4iAV0SwrafCOo4hALtKTkaFrcIiUonBS1ZbX37IsvCBIprv4vi/mQ0UROdlsnzJNisUikzdh6t9NN/ir164RA0MdGi+FfJ56oyHYelJirRNpOcTM9TyRY+9eTMGKcEZB6bUovXfP8xJD0GVWJJ1KMT0zgwaMDA8nZDYlU93ZNNJrQdZ5Iyhvpp4sSspuz+7dNJtNJiYnWVpa4tq1a5w/f34F4W10dDTZ55F338VxXZ568kmGR0bEOX6IkKi7+KU8qrpZO/nmAAuLi8RxzMDgIKlUCiuTES12uZzIfEk9e/VPDTRWWSZd11fOquohwKpCm24NHcuyaLZauHJYgi2705QjVOFqX18fU5OT63KVPgpuusFPT07SJ8X8FXTDoFAo0KjX8XwfTSlOyS8tnUphyIvbK2+rwhm9I5wB4fWb7XYSZ4LwwlYmg9WxSF5aXCSXyyXsSDUHtjOu7MQqMhldGYw4XuVtdcNgaHiY8fFxstks9VqN6elpZmZmOHr0KJ0N5q7rCgKVyjmr/akvW2ZQYkQRTxmQytZ0fn7nMa4VCi0sLJCRuuzqGoVS9c2yLNKWRSS16X0pGOs4jnAgcZzMalLQNY21yoSdN24cx4nMXuD71BoNTJk+VWnROBbzufr7+rh67RrT09Ns2rRpjb1/eNxUg4/jmHq9ztYefaKGYZDP58Xd7rpCs11xo+OYTC6Ho8KeHgYPy3lg3/dpt9tJjlxDhDqZNdr85hcXVzRqm3K8etBxo1z33GAFxWGthZryiqVymVK5zN69e3Fdl7Nnz3Lq7ClaQRMrzPLNl15KPP/I6OiytLYkuWnx6mZuFa58WCzMzzMwMJC81zAMUc4PApCGpxtGomfvy9lNgcz6aI6TNOHra6ybli/BsmPQZWEsZZpC1dhxSOfzy8rDcZzUFEqlEsQxi4uLd5bBJ+iR402l0+TimFazmejIqO6bXC5Hs9kUk6XVxZJQcaSm6zQ6J8YBuUxGqOauQdgKo4jq0hLjHb2V6qa4EYNf9ZhWKbwOLwysiMG7jXRicpJXz7/Gn6e+RpUlHi0/yl8Z/AlmZ+d45913ASiXSlT6+xkZHia3xrifOIpWyAaqJ896IUAQhiwtLa3oijIMAw160jk0TRPJBak7H7supq4n0n2WnN+01sK5cyGrileRTGUGvr9KJEuFRmrB/HHzaW6NwWsrJ2J05qYtqS/YardxbFtw23M5EVfKrqTOsCZGLDptyZdWhm2l04mo/no8nGq1ShSGK7p8VByvNN47lXo7veqKrIMydHrHsD258LFoeDl39ixnC+dptpsAvF17h5+4/yd4/r7n8VyXmZkZJicnmbh2jcuXLonMhZSvHhkeXq6KqnSg2r38DPWa+lvnMVSlNHbnE84wDEFEk5O3e2VnfN9PJqGnpUBrGIuJ3J7rkpKTPlahK7PWareT/ffSEFXXbb2Zud8JbgmXppe/6fQIlmWB5Hb4nkdDNnRkczncrrDGtm3qzSZEETlZYc1lsyv0KNcrgiwsLAh9+I6GCSVHreJ4XXZDdRpTjxPr/Xv3eSqOfxjyzjvvcO3aNfY/8ABfv/bSiu2m21PsH7iftGWxZetWBoeGRFWy3WZpaYnpmRmuXr0KSLrz6CgjQ0NCEbnTo+urB5R1ev2FhQUMw1h1/p2kvZ4G73lEQEbNiZJhoOISBbaNIcW1ekmSODJbptKTGctK+PPJApfVwlV3pIeP13nEAslFKJRKtJpNIbAv54GamobtOIRy4VSTUzvS6TTFYrEnCU2T7WK9sLi4SF9//6ovJWWaohrp+zekTb+KRtv1xXQu1jzX5bXXX6darXL48GHGNm9Gm+gO8VZ9gGh26e9n09gY991/P47jCK7/1BTnzpzh/RMnsDIZRkZGGBwcZHgtwltHqDU7O8vAwMCq8zcNg0AyIbvPPuhYG6U60pGWzHq5rivmZwUBgaIcq+xXFGHbNp6cYmil01iWJb5nRBhpSTFdWA4r70ipPU3TyBeLNGq1nrGl6rCJOx5jxWKRVquF7/tJFTQIAmZmZ7Esi1A2hvRVKusa5loLusWFBcY2b16RugMZ1uh6kgH60KmweCUXRYU4rVaLt958E8/zeOaZZ5JQanWqdaXFJ5qUHdtlMhm2bdvGtm3biKKI+bk5UfWdneXihQugCbHTYdnpVS6XVxxT4PvMzc/zwP79y58mw03FUg2j1fwVxflJdfYjJ2/XBP03laLRaIgx9O02VjqNBjhyzm4chmRzueV5raZJFAT4QSA60uJltimIirZhGDemAvchcFMN3jAMNm/ezJUzZ3A9b4WagIrjuweDaZrodnfkhDqARrOJFwSMjo6KtJa+etxMN/QecbXv+zRbrZ4CrIoIpWY2XW/i9qobqketoFqtcvz4cTKZDM8//zz5FVXXrhtqjSfEWqrDmqYxKCu6+xGTAqcmJ5mZmeHM6dO8f/KkoDvLrM/w0BCzs7PEYbiiBqA+S5ejLBMOTcd6JZCM1PWuuWkYFItF2radzHEFEa6ahkG2k7aAIJPFktLQy7vPz8+TLxZXHet3ipsew2/ZsoX3jx1jfn5+RWYE1o/PMpmMkHGWYyDbrRaB5xFrGibriH92IQmrgHqjQRzHlNYQW0qlUkSxGM2+3v57rUu6peimp6d5/9QpBvr6eOKJJ1aFGhrre/jOBf+NIJfLcc+OHdyzYwdhEDC/sMCMzPtfunQpybakLUswK7ueYiqGD8KQKAjQ5fmHQZCEMzdyzTWWMzFRFIk1Vo+R9srBBB0ZNkVMM02T+fl5du7adef1tPb39xMBc7OzKwz+eksRV67+S6WSKIW321TrdQzTJJNOX7/nFVYYIJCQkdZSF0ulUgnfppvYdsOIY86cOcPJ999nZGSEw4cP9zSU64U016u0rucsDNNMmtgBWs0m09PTHD9+nDCK+NpXv0oun2dU5v0Hh4YS3ryuaUQsS9J1ztxaU50hipIFrB+GaLpOsVBI5sX2GlimxLhUCBXFK3n+S7UaL3wEnc/r4aYbvGmaDI2OMiGnaugyi5DkZnss+GzHwZUdQJZ8LM/NzVGt18noOqEsaJmmKcacd0r3sVz97M4NNxsNMnJB1QspGccqRuGamis9/qZpGnEYcvToUS5eusT27du555571u4K6jKe6AZi+HU/v/enAGLm7ODgIGEY8sQTT6BpWsL4vHDhAoacoNjX10epVBIVaNMU0oUyfu/Vaqf6iRWFQ1V9C4VCoibWarWI4njFFG6QTwuZFVOGrmxiZmYGTdc/krDt9XDTDd4wDB544AHeefllLl2+zA5Js1Xorh46HcaelePbYZlphybGpKiL1Wg2k854y7JWhBs6EHQ8uhuNxrrakYrjHUmx0V5c/F7HDMITvvbaa8zNzXHw4MHlOUdrxeDdf+i4MdUNC/SchrIeWWwtTE9PYxgGw8PD6IbByOgoD8YxzWaTGdnne+bMGUJJd940OkrfwAD5fF40jqheAZm6VFwlIJHryKk5WtLR6LpOvlCg3WoRylqLIgsacgEcxzERYmavqiyfev99duzcuYJ/9XHhlnj4gYEBNo2Ncer999m6ZcvKPK+mJfwQxZMHQTPo9CpqsK5t24zJxavjOKIAIg2/LbMDaVUE0bTlwQGIgQz919EdT6VSBDI7tJbBr3oi2TavvPoqzWaTp556iv7+fhrN5nXK/mt7+GSx3VWwW3936283PTPDkDT25bdoFItFipLubLfbXJuYYH5+nmsTE3xw4QKarjM4MCBCn8FBDJl/15HqBaZJtoNRqfp9FXRNI5fPJ0bfbrfJ53LJjSHfJDrjNI3pqSma7Tbf9V3fdWPn/SFxSzw8wJ69e3nz1Vc5/8EH7NmzZ+VGMlujBDTTMlfbiUKhIDRQZIuYGl1uSc0T13UJwpDQcbAdR7SUpVJJuBNFEY1mk21dT5hupEwTG9ZNT3aae61W49VXX0XTdZ5/9lmK5fIyRWEdI9S7epe6ac2wdoZmrZBmreN1HYeFhQUOXKeDKCU1fgYHB7Esi9m5Oebm56kuLvLe8eNEsRBt6uvvF83uw8OrBk7Eur66xVDTBFWk1RJPh87mn1goR4SyT/bcmTOMj4+ztcf0848DN10uWxUgsrkc99xzD6dPnVrdrypjvDiOMQyj5yADle81JH8G+VTQEIN9K+UyxUIhEd0PfJ+WbVOr1ag3GmLadBgKUtJ1jldJaXdydHphemaGb37zmyLt+NxzlDrYjuqY18J6Dvm6ejZr9Hqutf21a9fQYIU2ey+osMXzPGqNBrqmsXnTJh46eJCnnnqK/fffT7lSYXZ6mrfefJM///M/5/U33uDylSvYSnVhjcW0ruuJ9HknUS+W/wcxX8txXfY/8ADpdJrx8XE0Tbshb3/ixInE1n7lV35lze1uuodXI9q9IGDnjh1cuXKFN954g6efeip5vDquK7QK5eOvF8IoIpfJ0DSMZFR557aapmFZFpZlEeVyomoqMy5BEDA3P594Ttu2MdWaoAfS6bSgw64T1ly8eJGjR48yOjrKoUOHEi53zLIHXtfgu9OScdTxe5xcu15YK35fK7a/du0aQ8PDa56LWrMEQYBt27Slxr6GSA+nUylyuRwDHfyjaoe+57vvvEOMYDgqcdu+/v5VT6hUKoUldYBUh1Us08CtZpNzZ8+yc9cu+uX65/Dhw/zBH/wB77777nWLgX/v7/09wjBk586d/I//4/+45na3RIjJsiw8x8EwDKEy9e1vc+zYMR46eJA4ihJ6cCabXZM0FIUhhmmSzWYJ4pjFapWMJIt1Qw1My2QyhJLX7ckYUdd14Y0cR1QYpd6l6mEFknK553nE2eyKhWMcxxw/fpyzZ8+yc+dOHnzwweUvQmWcehHHuqBpXSENq0OaXl/wevvsZeztdpv5hQUefeSR5f1LAw+lkScyH7LaGfg+mXSafD6/5iK/U9/T8zxmZmeZnp7mwqVLvH/qVNKqp/6pENWyrKSHVv10bJvjx48zMDjI/v37E3Lc448/zh/8wR9Qq9U4e/Yse/fu7XksX/nKV/jqV78KwC/90i+tvfbiFhl8JpOhISdi9w8M8PDDD/PuO+9QLJUYGxsjjoXkQ0ZmWXpBCayWKxWq1aogmTWblK8TohiGIbgdmpgHWsjn8X0fX3I7vFj0u9qQ3ACGYRDIgovreUmjSBiGvPP221y+coUHpeJxL9xI0Wi1h49X/X699cOqffag6F69cgVD1+nv7096Bjrz3YpeYcgbPorjRPT0RsfAp9NptmzZwpbxcaIoYm5hYVnh7do1QBDelPEXikVs206SA5cuXsQ0TQ4/9hiGrieZuccffzz5jLfffrunwfu+z9//+38fgGeffZYf/dEfXfdYb4nBp1IpdNMkkvyY7du20ajXOXbsGCCKU5lMZt10WxCGxFFEyrKolMssLi1RrVYp5HLrT+6WcDyPjMz8KG8ThCGBDHk6bwBNtZ+5Lq7jUCgWCYOAo0eP0mg0OHToUMLH6aY9E8erCl490c0sAJGVYbmSq9YS6rW14mPVFheGIb7s31XKaFeuXqV/YECcX8f2pjRwU2rrqJvTbreTFr4bJXB13mi6rtPf10d/Xx/33XsvjuMwK73/+fPnOX36NFY6Tf/gICnTZL5axXFdnn3mmcQzKwrKo48+mvQ/v/XWW/zkT/7kqs/+jd/4Dc6ePYumafzqr/7qdY/1lunDW5aF67rJKPP79++nWqvx3rFjHDhwIMlb66yukCrxIWLRCFIsFsU4FddlqVZbNcqyF7wOT61gGsaKwpAqgiiKrCu1IWv1OsePHSOIIh566CGyuRzVWk3QipWimLYsfef7vljwalqyOOvsAdA0Db0HtSCWJX91HJHsLwUS1a9YMhejWDRcq2sTS+KXWvDGcUy71aJeq/HAgw8m6mdKjaxXfl+FOKqyeqNY1V6oLTd9ZDIZtm7dytatW4miiMXFRWak0kO73SbSNPbu3k2xWEyOqSxtIZvN8uCDD/Luu+/y1ltvrfrchYUF/uf/+X8G4Kd/+qd5+OGHr3ust8zgM5kMbqOBHwRkEBdl//79HDt2jHePHCECdu3c2fO9q8IcTaNSqTA/N0e9Xk+aEtaDIydQrMWiBBKvB5CTxzg7O8uJEyewLIvHHnmEdColmJxS6UuR3xRFONaEtrnjuqSluFCnZ1ZGn/PzDDKAT4CGRmyLFGccxzTbbZAhnKonKK+/1iBmQ9cxdR0kPUA3TSauXUM3TTF9+waegq7rolQDenHie6LXk0frDtgEDMNgcHCQYqHAzOws6DqFfJ4R2cIXSdp3p57k448/zrvvvsvRo0dXNOcAfPGLX6RarZLP5/nyl798Q4d7Sz18JLtq1LgUgAceeICrV69y7MgRmo0GB+QiUBl52OGxYpYNJpvNYmUyhLbNotS9WQ+ubTM4MJBIT98I5ubmOHbsGOVymSeffFKkPCHRk1QGr7ysImX5vr8su0dHP0C83JwdsyzAqiPqEAnRTbW5SQNW4Y0uiXOa1NnXNKHPriMqlMrrK1y7do3NmzbdkLEHQZCkYa10+oZUgdU5rfe3TlJdFEU0Gg1eefVVwjBkfHwcK5tNzi+O4xWNKSAM/l/8i39Bu93m5MmTPPjggwC8//77/Kt/9a8A+IVf+AXGxsZu6HBvmcHruk6mI12o4m7DMDhw4ADFYpGjR4/SbrU4dOgQhmmuqNj1MtH+vj5cx6Ft27RkBa8X4jjGdt0bkl5WRnf69GlOnDjByOgoe/buXTGsAcSNp0FvY5Ke2bKs1SQ0afRuyqHKEr4meSTZiFLHYAKgp3z3eobYueXM7CytVotHH330hoYcKDpHOp1eQdldF+usKxRilo15ZmaGN954g4wMVZqNBihastxPpSs87Vy4vvXWW4nBf+ELXyAIAsbHx5NF643glsxpVcjn88S6juu6oqkgjpNc+I4dO3jyqaeYnZvjpZdeYmFhofdOOgzATKUoFIuYus7CwsIKeY5OBEFAFIZiYbxOuV4t/N5+5x1OnDzJvffdx4MHDmDcgLhrgrhDsqPX52haEquGRIQERITLQlAdKc1VDTM3dgQAXLxwgXKptKJ3V5P/dHmcCioHH8dxUhy6kYX3Wk/K7rMOgoCTJ0/yyiuv0NfXxyMPPyxEnqQeTuck8r6uiYK7d+9OzuHtt98G4E//9E/5z//5PwPw5S9/+YazSXCLDd6yLAzZzuU4DmgaRkfsPToywgsvvICm6/zFX/wFx44dS/jSa13ccrksdGWiiHnZdNANV46z7KVYq1h+oWQGvvraa1y5coVHH32Ue++9V2QMZKoukjH6urhh/ktvLo3y370WlTfkdRGFtampKe5Zg22oQkNdHoXiL1npdKJgcN2wb404Xb2mMDc3x9e//nXOnDnD3r17OXjwYNJsokZoqkagXD7f8yl8+PBhQHj4IAj4whe+AIgszk/91E+tf5xduKUGD5CXhYxEFazrwpZKJZ5//nkePHCAS5cu8bWvfpXpDsm1bmPSdTHowNR1Wq0WzWZz1Wd6ngeyEtuJOF5uK7Pbbb71rW+xuLjIU089xVY5eyqVSglmHyRPpeviBrbRuwpPSYdRZ/z+EfYLcPHSJTTDuO4onxhxbVTcb1lWMrBZfNwan3edUEbt99133+Vb3/oWZirFd7/wArv37EmyTqoBRFWoQUwC6QUV1hw/fpxf+7Vf4/Tp0wD86q/+6oduxbxlMbxCLp+nKU8y8H20XG5FPlst6nbv2sXY2BhHjxzhlVdeYdPoKDt27qSXNKmVyVAsFqnV68zNz2NZ1oq0Wic/XnG2geSLq1arvPrqq+i6znPPPbeKb2NZFu0wxPG8NaW5V6Cz8rrWJqs8vGyEWItHE6+joNC5nzjm4sWLbN2y5fptiupJi7iGhnxSdr7eq4dVdUD13CcwOTHBkaNHCXyfAwcOJE8aRQ5UOvGdSQiAwTXowMrgPc/jH/2jfwTAj//4j/P000+ve369cMsNXtM0cpUK7XpdjKTvjlPjODGUfC7Hk08+ydWrVzly9CjTMzPs2LmTvXv2rBpFWalUROOI5zE3P89Yh1qV0pGR/1lxLJOTk7z15psUSyWefOKJVfsFsFIp2iB01KXW4g2d67rXoesP8rDWHHV5AwtENDEh0XGcVX0HveA4TrJ2ULIZao2z1ietJbsSIxQRTp8+zfTMDCMjIxyUNQsQYVYoZ7talkWz3RbrCZkMUMpsvXD48OFkYev7PpZl8Uu/9EvXPb9euOUGDyKsmdN1Iqkcm0qlljugurbVNI2tW7dSKBQ4d/48Fy5c4MKFC+zYsYPdu3cvZ0E0jaHBQaampnAdh6VqlT6Zz+0cU9OJCxcucPTIEUY3bUqqer2g6boonMn8eu467X9JCnWdbVYvSG8gpLkONODCBx8w0N+/pvEoBEGAJ71splBY8VTSWJua3I0YmJqa4vTp0ywtLtLX18cTjz/OaIfD8aU8NpAQ/gLZOqg6nzatw+Qsl8vs27ePU6dOAfB3/s7fSfT6Pyw+EYPXdZ1MsUhrYYG2bZPL55cNYI3JE5ZlsWPnTvbs3s3E5CTnz53jg/Pn2b59O3v27hWdOakUlb4+lpaWWFpaIqPYk1KGrlOL5cSJE5w7d46du3axf//+68aCVjotejY9j0jFuuvgevtbiy2pCksfxeBr9Tqzc3M8+uij624XI9oo0fVEtXflwS1XhNeS0IvimImJCU6fOUOtWmVwcJCnn36awaEhsbhXufcwxJbMSMuyEtWySOrB65I6PnydOsrw8DCnTp1iaGiIf/yP//ENXpHV+EQMHqBvaIhWtYrnuji2TTaXE4/zNQxF10XLhGEY7Nu3j927dnHh4kXOnjnDxUuX2LJlC9u3b2docFB0QbVazMzNMTY6uhwX6zpBEPD2228zOTmZEMBimaVZz0hN0xSqBp53XS+fmMeHIY+pn2qkTNd7Q3nTroczp06Ry2ZXqUN0w3WchI6dWaM20cnhUVkUTdNwXJdrV69y4YMPqDebjIyM8NBzzyX6MRokzdtxLDRqYkjqEjHLo4rUoOrRsbF1eTtvvfUW3/zmNwH4xV/8xVXFqQ+DT8zgLcsincvhNho4MqwxUimiIOhNi1WTOeRrhmmye/duduzYwaVLl/jggw+4euUKmWxWVPDkwnV2djbJxPiex+uvvUa9XufxJ55I4vxOHsx6yGQygmrsOEJSbl2DXh+9QpooWm70605LXm9/rVaLiclJ7rvvvt4pTYkoinBl7J7toj6v9VlhGDI5OcmlS5dEg7WmsWnTJh45dGi5d1edR8cazLFtUUnWtGVB2DhO6OCGrpNKpxm5jvbML/zCLwCwf/9+Pv/5z1/nSqyPT8zgVVgTOo7oTmq3KZVKa3pZZVxJrC+N0zAMdu7cyc4dO1hcWuLKlSt8cOECvueRz+Wo9PeTlQWnV155hSiKePbZZ1d9UUnueR0jTqVSmIaBJ2X/1vTyKsW47hVYnYfvnEL4YUOaM2fOkEqn122NixH8eGSz+noZpziOmZubY3JigmsTE/i+T39fHwcefJDxLVvW5ZyDmJ+rOpmyuVxyY6mUZYz47oaGh9eVRPnN3/xNXnrpJUAwI79TCb5PzOBBeJigUMBpNEilUti2nciudUPlh5UsNN2xpabR39dHuVzm/vvvZ2ZmhosXLzIxMSGoxTLD8uihQ8uDB+h8u2A+BtcJbTKZDL4cuHZDXl7Gs4rJqBa0ZmiSI4uPkKQjEFkT3/cFrSII0CQf53rpSLvd5vLly9x3//3rGoQrNTrjKCLbo7Ms8P2kgXt6aiqha+zauZMtW7cKQVvtOtO3JUNUtfwpjf44itANY8XE8bRlMTA0tKI+0m63mZycpNFo8OKLL/KlL30JgL/1t/4Wzz333HWuxPXxiRp8Pp+n1WqRVpMmYtmI0ONLU0boui5/+2//bWq1GgODg/zTf/pPky9ZLU4NXWdgcJB//a//NdPT01QqFbZs28Zgfz+vvPwyGSVAOjSU6K/LDxF6KuuENul0OpGJc103KcUDCbVYSVgEYYihBhp03BhxHJOO0+TIS7YkGIFG23FwXRcjDGl0bK9p2oohw2YXvffc+fMYpsmO7dvXnGToy6nhMUKlTDcM4jBkcWmJ2dlZ5mZnWVhYII6FRn9fXx8HDx5kaHh4leR35xNWyXGo//u+T1vm29U4HSBRZHYcR0gaxjHj27ZR7FIl+/f//t+vClsee+yxG+K63wg+UYNPpoCEIV69jh6L4QhJaNMRYui6jhaLxoUf+MEf5N//u3/H/Pw83/72t3n++edXeJ0ojvkX//yfc+78eXRN44d/+IepNRrs3btXyH3UaszOznL58mXQBL9+eHiYwcFBKuXymn21ChnLohWG2LadLNJ8OTJGY3ksY8o0ieWiL2noUDwaLcTBwcdHRyfURKyrphImi0Z5PrHku0QgOpTkdmEUcfHiRXbv3o0pe4e7oSrJYRhiOw5z8/PMzc4yNzeXKLgNDQ5y4KGHGB4aSkZcFgqF3jn3eFk3v9PYlUKcWqSqUEV9l1EcCyXhMGRkZIRKpbKqhfBdORDCsiy2b9/OT/zET/AP/sE/+OhKcF34RA0ehPxGu90mlcsRuS5xGNJoNoX+oxRETRos5Cyi5597jv/8Z3/GwsICL774Ik8//fSK0OLf/bt/x9vvvAPAT/7kT/L444/z1a9+NfFMe3bvZv/99+N5HnNzc8zOzjIlO3J0BAOyWChQqVQol8uUKxXKpRJmKpVoJrZtW3Tfex6mjGc1xE2ckk+pfC5HWqYwu71uaAY0aeLjo6ERpiKhwitFpTKZjAiF1KBh+fQIw5BQGo/v+5w/f54Y2LRp07LKgqbRajap1+tUazWWFhaoNho47bYwVqk1s2fPHoaHh1dqzMcx1TXUnhWU1k8n50aNvowlU1SlmlVYByJcCeXNumPXLnIdSmQK//Jf/kv+5b/8lx/Rmq6PT9zgdV0nn8/TiCKMMCSU3ULNZlN4mE52pGkSyPTYj/zIj/Cbv/mbzM/N8c2XXuL57/outDjmT/7sz/jz//JfAPj+z3yG/+r7vo+2jBt1+QVMzcywaWSEdDrN5s2bE/kK13Wp1uvUqlVq1SoLCwtcvHQpCXFymQwZacSGJEBlMhkGBwYoFYti+qA83iAMEx5OzwppjwqzekopI9A0odClxzF0UCWiMKRt2ywuLHD16lX6KhUuXryI43nUazVazaZo6YvFMOB8scjQ4CCDAwNU+vpWhRGd6GwgX1M1QYUx8vdQagopj68yMuopoNZcjUaDMAjYtmMHlmWtqwJ3s/CJGzyIWN62bQLLQpO9q67riouXzycLP8M00VyXIAh49tln+eM/+RMmJyZ48Stf4dlnn+XNt9/mP/zf/zcATz7xBH/1r/5VQKgQaIhFcjqdxvM8pmZmGBkeXpGHtiyLkaEhRiSnI4rFSJfFhQVq9TqNRoNatUqz2cSxbfwwTMIuLZYzq7JZUjIlmkmnhc6NYaDLdkJD1zFME6dtr7gGjUada9euJVLdiXeX7X5KQsO2bdq2nfCDiCIW5udpNptYmQyZbJbBwUHy+TylYhFNfmanNnsvqLh6Bc+oB5IwBiAW7YhtGcYotYjEs7Ns7O12O5kJNT4+vu5NdzNxWxi8Lrvq5+fnidNpDNmIbNu2uIhy8JVqdwtkBuPHfuzH+Gf/7J8xPz/Pv/2d3+Hll18mjmPuu/9+/tbnP79iSp1uGIRhyPDwMHNzcziuy8zsLCNDQ6t6XUGIA7Vtm0A2f2dyObZu3boilefYNguLi7hS8sPzPNq2TbPRoNVs0pQ3qi8lMbzIS7Ikk/o0oR4mxbYrU1c5NnEMdA1Nh6yRI60baJJCm0qlyGaz9Pf3k81miaKI48ePc9/+/ezZswelrua6Lo7n4buu4K84Dtl8fn0imdbRQiibP64XzoB4itm2naQYc9lsQizrXKjHcSy8exSxdft2CoXCDU8o/7hxWxg8iHClUqmwsLBA5HkY0kBbkmRkZTLLQwuk9zt8+DBbt27lypUrSa5227Zt/N3/6X9aNWA4nU7jex6mYTA0NJQYvSI6JY0PUvTT833xxUsejZVOJ8PLVPk/k81SLpcJcjlM00zmUDWaTYIgIJfPkzZN/suVr/G77/9fVL2qIGRLx6YjF7Sxxnn9PPP6PBERiyyS1bL83H1/k+/d8t2rrlUMfPvb36ZYKCTGDsLAzFSKvGFQ8/2kG8vQdZrNJhnLWpU/12DF4AhlzKvSrcp45X9dWSFX+89nsyuUoDtb+1zXpdFo0DcwwKZNm3qmhW8Vbv0zZR1kMhmRoUmlhPCSfOS1bFtMbEZ0OcHytIgXXngheX+5XOYf/IN/INKMXV9YWmq/g8ggjAwPi4KUrjMzM0PbtvF9n5oclqwaRkqlUjISHVjVAKKyByozAx0lpTjGDV3+j/f+uTD2daC0JkM54tcObP7PE/8KN/RWbTs9Pc383Bz7H3igJ424ZdugaeRkeKO6ymzbFkoBKk5ndWdTr26tuOv1tpy4CMJR5fN54Qw6ngxqv3EUMTs7i2GajI6NMTIy8qE57B8nbiuDB6ESnK9UiHU9ebyqi2y328liMQgCpqen+YM/+IPkva7rrnx0dzx+s7kcbXs5btZ1neGhISHxrOtcnZhgdm4u4dSUikWRr5Y33VoDeA3DSAb0Jvvv8IZhHOFH62tUAhiIhWrIyvRqd6NIFAvls6GhoZ7jYNpyErmGWBulLYtCoZDc3EEQ0Go2E2GrbtOLwnBFONLZEqn03tXMp0wmQ14lFmRI1UmPiKOI+YUFHNelv7+fnTt33rRhZTeK287gQXDbC/39Kw1MLiBd1xX6JktLfPl//V9pNBpJPOg4Dl/5yldW7Et9WaVSiXqttuI1XdcZGhwUfZW+z/ziIo7jUCoWe34xay2y1DDlUA4I6DzmfCrHk5ueuO45GzK6DFnOoz8/9iwpfWXUeeHCBRrNJg888MCqfTiOI6blwYrhA6rbqyCncMRAs9lcNQMLSHhHyrF05tibzaboG9aEBmjSO9CVPgZx49TqdRr1OlYmw7777/9EQxmF29LgNU2jf3CQguK7dBh+FEU0Wy3+3e/8DtWlJQzD4B/+w3/II1I78Wtf+xpL3b2tmkapXKbVbidzhBRcyXxMZzJkLQvPdZmdn1+zfN6LSpAsrBFhQ3eY8N/sW62Y1Q0z8fDLOjc/sfsvr9im1W7z/vvvs+Oee1Zot6jzcGSjeU5O1Vv1GaZJUTa9o2k0W61V56mkRnTTTNiSruvSkjeIbhgUCoWkh4EoQotjOveibo5Gswm6zs7du6/bbnircFsavEJleJiiKorIBVEYBLz44otUazXy+Tx/9+/+XbZu3coP//APgyzG/OH/+/+u2le5VII4FtIQEq7nJVmGTaOjjAwPC4UCx2FqZqanXLZGb+ZiRubmY5YlLxR2lO7h6U3rt6MZXQb/3Obn2Jxf1lqJgSNHjmCa5oqx8SAySrYMpzJycNla0DSNfD4v1keallRG1WfEMiTRNS3Jryfxeiol3msYiWR3rC2PlI/jGMd1abVaiRjtlm3b2Ldv3yeSguyF2+Mo1oCu65SHhymUy8nEiD/+4z/mopxL9NnPfjbJUmzbto2DjzxCEIb8xTe+wezs7Ip9laSUmxpsFsqUWhTHWJZFJpOhWCoxNDSEKSu6k5JA1Yn1shjZfF5QCzpEjRR+at//h7VIvrrI14jjIgQ0/uqun1ixzZUrV5idneXgwYMr+nU9z6PdaqFpmsj990ixdkOTil+6JOOpVj+lUamx7KWVaoSVySS6P3G8Ur1B1QyarRaupAS3bZvRTZvYuWvXJ5aC7IXb2uBBkI6KAwOUymW+8Rd/wVtvv43v+xw6dIg9e/dSrVbF4Kwo4sd+9EdFOiyK+I+/93vLxRmkd8rlEoN3HIcgCERRpsNIFLHMkpND5ubmqHbE/horF3SdMA0DSzIo1VpD4Z7Sdp4de6bnOSrvHijvPv4M44Xx5HXHdXnv2DHGx8dXLFQ7ddZNmadfhTUyIpqui+11Hc91hXy1nMThyJSjKvYVisVEdW0Vj18uZJvNpmgS0XU8z6NcqTC+dSubOlr9bgfc9gYPYKbT/NGf/Rn/z+//Pna7zYGHHuLpp58WF7vdxpF53tHRUQ4fPkwcx7wu9WWUyE8cxxRLJer1uhAplZ6rVwrTlGMfC/LRX6tWmZEhTudCrtP4FbJySkkESZih8FP7fpJeXn7lglXjc7s+t+L1o0ePoul6oroFImyyZfoxnU6Tz+V6shrXa/xOmaaoQkuhqXarRVtSBJC0ibzixPS4cdRQOdXQkU6lCHwfM51m0/g44+Pjt00oo3B7Hc0a+NM//VP++uc/z7snT7J3717+2s/8DHmZajM0jYYcdtZsNvmvP/OZJDX5e//pP4kdSIMvlUrMzc+LFsB4WTK6lxfUNDHGva+vT8T1nsfk1BT1en3Fl6/RFd7IDIZiTXqyWTmOYzbnN/P85tWc7s4F69NjT7GtuDU5ponJSSYnJ3nowIGEN+7IOVYgem1XKW9JusN6HVxqXWRZFr7niSelJHdZ6TSFQiH5vG5jV+FOq9kUSsvyaeHKwdHjst3ydgplFLT4RpVFbxM4rRZeo4EmGYHzCwvJiEnf9wUH27LI5XKk0+mkzB3HMQsLC3zjpZc4dOgQ2VyOfD6PJQfurncRfN9nYWFBfKFRhJFKMdDfv0pSWmVnHNsWM6ViIV1XlAPZACaaE/ytl/67pGnbDwP64j5MTBo0+P89/0/ZXtwOiLa9v/j61xkaHubxw4eJIZlcGCOeJp0xeyBThsn4+LUgt/HlMOGaLPsHvk8mk0lu8k6Kstq/mpqIfE1Ppcim09TqdXzfZ/O2bWzfvn2FxN/thDvCw3cik8+TLhTERLlCgb6+viQWzeXzBGFIQw4xq9VquDJ0UQplVjrN3OwsaihADImKr3oSJD8lUnJ8S1+lgmEYeK7L5NQUtWp1ZVpPE83OURSRksUokG11cn+bi+N81+bnV5yTiuEfHX2E7QXRoheFIW++8QaWZSUpV9u2k9Rjt7GLj9d6tyl2hGBxHOPYNvV6XaRpo0jQmXUxecNSIz9ZNvYVHl0ae9qyyOfz5DMZ6lJjaGzLFrZu3XrbGjvcgQYPQkfFyufFoLNcjpRlYaVSwpsWi1iyDa9er7MwP8+iLChpmsbIyAjzc3MYUn5aodPLx/KfqhxGsWjLKxSLCe9G1zRq9TrTMzPJAjXqaL7QNC1ZDAdRtDzlLor4K7s/h4rldYwkQ/O5PZ9LjPXosWPUGw0eO3wYwzBoNptChluGTMrYV4zKEX9YwVOPI6FpFslsTL1ex3YcUcVFpDHL5XLCE0opJyDHSzYkES4x9EyGUrksGsA1jWqthuM4jG3ZwpatWxm8zhzcTxq3DXnswyIj04x2rUYukxHeKggEJSCbFVRaqSPTbLVot9ukLYtKXx9Xrl7F9TzBJaF3sjDpm5X/72waHxoaotFsslStEngeE5OTZLPZZDCD8uyaJFU15cJONU5vLo6zt28PZ5bOJPH7QHaAnWUhSXf58mUuX7rEwYcfppDPU5chnKaLaddqIrkq4yfV0DBM9O8VDz2UoYsSgwXh5axMRoR8km4QRVGie9/sMHBxGTRS6XTSDK+GPiwuLaEZBpu3bWPz+DjDw8Mf4zd8c3DHGjyAlc9jpFJo0oMHciSiGrWYz+dFlVAWQhzHEf2gmsbEtWtUyuWEPZg0KnQh+VsHP0bTdQqFAhnLYmFxEV/eUK1Wi1wuRy6XI5LGZxoGaTnFsNlqUZSteT//4N/hf/jm/4Ae6UTE/Df7hAputVrlyLvvMr51K6MjI6JaiUjPKrpA4sklDz+ZrySzKWEUEcgFc2dlWZeLVMX9UTdEu9USDeRBIDy33N4wTax0OqFEq8Vrq9ViYWGBSl8fgyMjbNmyZZUKxO2KO27R2gtRFFGdnWVBFpsKXbLLShqiLfPFJ06cwAsC7t23LynWZHM5oZ6raWsav9pXDERy5GIURXiumzzakRVKTdMoFAr09/cn6VPF41fpzumFGX7vG/+J7zn4PWzdJErv33jpJUzD4LHHHku4LinLWsHY7EYYBMSahi0Zn36wsq/VNE3SpklKnl8oh7gpXfh6s0mz1cI0DPr7+kilUokiWWdTeBzHLC0u0rZthjdtYnB4mC1bttxQset2wR3t4RV0Xad/dJRY01iamRFeUdNEjll231jpNFY6TalcplarceLkSVqtFoVCgWazSbPZTEYmqp5SNWamcxHY2aOpjCFlWQwPD+O4LvVqFVtOJVFN3sVSSYxebzaJ4phWq0WxUCBjWIwyimUIOcBXX32V0Pc5+NBDSTUzm82uqQ6m5q36vi+ecB0LaEPXSafTSSYpCAJsedN1+rgojvHkbKf+SkX0Esv8vSo0aUDbcahVq2iGwfg99zA6OsqmTZtuuzz79fCpMHiFgZERQqAuh50VZYWws0Bk6Dr37NjBhYsXWVpaYvv27di2jStDona7TbvdFotamadPp1Kij1VfnoLXqaKrFr/ZTIbM6Ci2bTM5MYHn+zRbLZqtlkiVZjJicSuJW8n49Sji9ddfp91uc/Dhh0WbnK5TyOWSRSRIGRDlnWUrpIKiBBimmTSNe/JG6IbqHjNlj0AqncaMY9Fjqm7uDkOv1+v4rku+UmHT2Bjj4+PfkdzdJ4lPlcEDQkdF06jNzdFutcREO6nnogw/Y1nsuOcejp88SRAEDA4MEEpPp1J/YRDgS70cNbTY0HW0jrmmapiYoeviMzoWloODg6JpRS0a1WRvGXNnM5nEGM+dO0ez2eThRx4RHHYZN0cyuxOGIUEYJoPPVO9pHEVCrKnjBgwDRVBYhroRDMMQ4ysNA0OGbtVajVhmu5SEiCbDo1q9TuC6xLpO3/AwO3buZHidEfZ3Aj4VMXw3oihibm6O5uIioZTcS0lPj1zYNRoNvvHSSwwMDPDYoUMrYvZINif7UlLal4u/SE7njuNYaLdIvXPlUTvlOBzbBl1PCFe24yTaMGEU4Ul5watXr6JrGjt37aLckeXpzL7E8bIMn2oKN00zWaTGsNySKL23Lp9E6h8sZ55USNZst8VsrCgSnUiIXH+r3RaGrgl1351797Jrz5472tAVPnUeHmRjx9AQuq7TWlqi1W6T9n1R8lceVqrsnj93jrl77mG4I3+sS+ahUiHQEDLWQRAk2Y+Efy49rrpJkj5Oz0vy+L7nMTMzw8zMDPNSYcA0DNE4YhhsHhsjCgLRNO77mHLRmNxIhsF//L3f44033uDBBx7gv/tv/9vlJ46mgWzyNqRCwQp082k6Gjpq1Squ5yVD4TzPWy7MaBp9fX088NBD9N3A4Oc7BZ9KD6+guuWri4u4zSY6ohNIlflt2+ab3/wmYRTxzDPPJJmQ63VcxggeuOu6orATRfzRiy/yp3/yJ/ziL/4ilb4+mvU6jueRzWT4J1/6kujd1nXSUmtR0zT6+/spFIvcd999CRXCkJIiKdMknU4nC8+jR47w5f/9fyedTvP//Mf/uILzrlQRrgelKOb5PjPT07TlVA6l9KYhniDZXI7tO3awbceOO25Rej18Kj28gqZplEolLMsS1dZGg0ajQVoOSshlszz80EN88+WXOX78OA8++CCWZSWxfkID7t4vJLJ/oRyBo7M83r6Qz2PqOo7jYGUyNJtNQXQzDHKyB3ZudpaGlP/bt3eviPNlJVVlUpIR9sDY+Di79+zBdRxeff119t9/f1KAUk3n3VBZnCAMCXxfTEKBJO8ehiGVcpmMnCeby+fJ5/Ns3bGDwicgknQr8Kk2eAXLshgZGWEpnRaqXO02Tq1GOpViYHCQ++69l1OnTtHf38/msbHlsr3aQUcuujMXbmgasWEkjc+dc6QSXrnj8Nkf+AHGxscp5PNcuHiROIr4kz/+YxGCmCZ9lQrNVou0FHbKZrPEUpdHFY90TeO+vXu5dOkSly5eZMeOHUmXkSebtjvRSWFOZPFkzSD0fVKGwdjYWMIPSqXTDI+OMjgy8qnz6p24KwwelsljhUKBVqtFq9HAa7dpNBps3bqVubk5zp45Q8o06e/vX6V72LmAhOWbQS1a4zhOJL+rtZrwrL6Ppuu88MILXLx0iXNnzzIyMsKOnTv58z//c7XjpHLbarXwpcJYKpWiXKkk4VcchuzZvZu33nqLMAz57Gc/myym1VTzVeesaclNpZR7DcMgnclQLpUoFovC0GUR6dNs6Ap3jcErWDKcKZVKotG4Xsdrtbjv/vs5duQIx957jx333MPAwADZXI5M5zwn5d1lS5viqYSy0yeXzQoVYdn1b6RSNOt1jh09ih8E7N+/n127djEzN5dQAJKqqCamZLiui+04eJL/klU0Z03j4Uce4d/8m3/DtYkJ5ubm2LljxzLTcw0okVPHcWi12+i6TqlYZHBoiMGREQaGhj5x6YxbibvO4BWU0lmpVBK5d8chXy7z1htvcP78eWzHYWR4mIYmhPvX0mXsJGTFLLMP7XabEydOMDs7K0Y4PvxwkqIMfF9IBnZ3UMkuIzOVSqqiiSajZVEql7nnnnv44MIFjhw5wo6dOxM1YGRlVpP7CiU70nUcPM/DlTfP6KZNbNm+/bpT/j6tuGsNXkGpF+fzeQYGBthyzz38xde+xntHjlCtVtk0Okpffz9RGJJKpxO6gqpoqoEHAM1Gg2q1KmYhTU+TSqfZv38/27ZtS+SvNU1LCF1KCa0bppTCUKoKnueJ8r+uc/Dhh7l46RLvvvsuP/7jP778JpllCYJAGLjUqPFcl0wux7YtWxgbG6PS3/+JKn990rjrDb4bpmnyvf/Vf8XO3bt5+dvf5siJE/QVi4zLRWdGce4la7Fer1OXvPgYIei/ZcsWHnn0UQYHBwUtV4oUxciZsbJi2knZVUjUA6Ioya0ryYsojrn3vvsoSu2di5cuMSyVjj1ZzfWDgFg2ZBdKJca2b6dPSmSvagW8C7Fh8Gtg586d7Ny5k+npaV595RXeO3UqWaDqiDy51tFdpGi8Tz35JDt27gSWva3v+4nRK42XwPMSr9ydUuzk/qh+0UwmQ+D7pDZvZrC/n4XFRY4fP85DBw6I7q1UCt00sfJ5crmcCNcqFUFjljz2DWwY/HUxOjrKj/7YjxGGIfV6ncXFRWZnZ6nX66KrP5Mhm07jBwGXLl7EME3a7XZS/lcxuicVkdVkO9WqtxZ0uaiNo4hQNmcorfjde/Yw+e1vc/zkSb7vB34AU/bx5qWxq5mynwYqwMeNDYO/QRiGQV9fH319fezs8OCqsaTheZw4dw7DsgiiiFimF9XCsd5oJE+IwPeFUUqymRoooIhliShpFIEkpemahmYY9A0O8uhTT/Gvf+d3OHn2LP/0134toVFs4PrYMPjvAErmIy914SenphgYGUnmLSmPXJUdWWEYCl1H02ShVkPXddwgIJXPJ8xLNarSkA0YivylvHYqlWJ00ybm5uaIY6Ek/Jf+0l/6ZC/EHYQNg/8YEQQBmUxmBVc8jmOGhobEDCQp63flyhU+uHwZTdM4eOgQ41u3JlQGxbrsHFPZja9+9auJfv3hw4dv5Sne8dgw+JsMTdMSEphCVjZ2g8jafNjhXn/0R38EwAsvvPCJDAa7k7ER+N2BUBr4n/3sZz/hI7nzsGHwdxiOHDnClStXgA2D/yjYMPg7DCqcOXjwIOPj49fZegPd2IjhbwFefvllzp8/n/x/fn4++f38+fP823/7b1ds/9f+2l9bc18vvvgiAD/0Qz/0sR7j3YINg78F+M3f/E1+53d+p+drr7zyCq+88sqKv61l8FevXuXIkSPARjjzUbFh8B8Tnn/+eYCbOrhLefctW7Zw8ODBm/Y5n2Z8qntaP2343u/9Xr761a/yt//23+Y3fuM3PunDuSOxsWi9Q1Cv15Np4xvhzEfHhsHfIfizP/szfN+nVCol4dMGPjw2Yvg7BH/xF39BuVzmh37ohzZYkN8BNmL4DdxV2AhpNnBXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgN3BXYcPgbyEuX77MF77wBfbt20c+n6e/v59Dhw7xy7/8y7Tb7XXf+zM/8zNomsaP/MiP3KKj/ZQi3sDHgi9+8YsxEF+8eLHn6y+++GJcKpVioOe/PXv2xOfOnVtz/7//+78fA3E+n49t275JZ/Hpx4aHvwU4cuQIn/vc56jX6xQKBb70pS/x6quv8vWvf52f+7mfA+Ds2bN8//d/P41Go+c+vu/7vg/Lsmi1Wnz961+/lYf/6cInfcd9WrCeh3/mmWdiIDZNM3711VdXvf5Lv/RLiaf/4he/uOZnfOYzn4mB+POf//zHeOR3FzY8/E3Gm2++ybe//W0A/sbf+Bs88cQTq7b5whe+wL333gvAr//6r+P7fs99qVE3X/nKV4g3ZP0/EjYM/ibjD//wD5Pff/Znf7bnNrqu89M//dMAVKtVvvGNb/Tc7gd/8AfRNI2pqSneeuutj/1Y7wZsGPxNxssvvwxAPp/nkUceWXO75557Lvm9e26rwtjYGIcOHQKWR1hu4MNhw+BvMk6dOgXArl27MM21R2rt27dv1Xt6QYU1Gwb/0bBh8DcRjuMkY+bHx8fX3bavr498Pg+IidtrQY2cP378OBcvXvyYjvTuwYbB30R0phgLhcJ1t1cG32w219xm//797NixA9jw8h8FGwZ/E+E4TvL7jYyatCwLANu2191uI6z56Ngw+JuITCaT/O553nW3d10XgGw2u+52Kqz51re+RbVa/egHeBdiw+BvIorFYvL7emGKQqvVAq4f/hw+fBhN0wiCgLfffvs7O8i7DBsGfxORyWQYGBgA4Nq1a+tuu7S0lBj8li1b1t325ZdfJo5j0uk0hw8f/ngO9i7BhsHfZNx3330AnD9/niAI1tzu9OnTye+q6roW/uiP/giAF154YcVTZAPXx4bB32Q8/fTTgAhX3nnnnTW3++Y3v5n8/tRTT627z6985SvA8uJ1AzeODYO/yfjhH/7h5Pff/u3f7rlNFEX87u/+LgCVSoUXXnhhzf0dOXKEK1euABsG/1GwYfA3GY899hjPPPMMAL/1W7/Fa6+9tmqbX/mVX+H06dMUi0V+/ud/niiK1tyfCmcOHjx43WLWBlZj7Vr3Bm4YykA1TVvxN9/zCIOAL/+Tf8JnfuAHcByH7//MZ/gf/vv/nsOHD+M4Dl/54z/mP/6n/8To6Cjbt2/nv/6+7+P8mTMMDw1hZbOkUinMVIqUzOOr3LtKTW7gw2HD4D8CHMfBtm3CMMRxHNx2G99x2LFjB6eOH2f22jWIY3RdJ2WaFC2LX/7yl/nlX/s12u02v/nbv81vdoQ3mzdvZvu2bfzcX//rtOp1mtUqs1NTFAsF0DTa7TbNZpOp6Wk++OAD8vk8nm3zH/7Df2B4eJjBwUHGxsYYGhr6BK/KnQEt3iBW3xDiOKbVarG4uEizXqfdauG7LoHvowFnz5/n7PnzvPDcc6LgFEXE4o2k0mkylsXC4iL/74sv8sabbzI7P49pmmzetInnn32W5559lkqphGma1BsN/CCg2WgwPT1Ns9kkBo6fPMk3vvUt+ioV/v7P/zx2u03LcXAdhwgY27yZZ557jl27dq142mxgGRsGvw7iOMbzPKrVKtPXrtFutQiDAA1IWxamYaDrOqZpYhoGaBpRGIrWpSjC933CKELXxVLJNAyyuRzpVCr5jFa7TbvdRjcMKuUyzUaDk++/z8TkJHEYMjo6ytjmzRQKBf6X/+1/4/TZs3zX88/zuR/7sSSUCqOIarXK5OQkbdumWCrx0MGD7Ny9m2KxSDabxTTNjZuAjZBmFaIownEc2u02rXqdRrVKrV4nCgKiOCadSpGxLHTDSMKWKIrw4hgd0HQdTdMwUilSlgVRhB8EuJ5HEEXUGw3SqRSFfB5d03BclziOSaVSnHr/fU6dOoVpWYyMjjI0NMTgwIAIa1otjh0/ThAEHHr4Yfr7+oiiiDCKCMOQQj7P6Ogos7OzTFy7xivf/jbTExOMjY+TLxYplcv09fVRqVSSG/BuxIbBs+zJVazcqtWoS0NvSyJXyjQp5PNEcYztumiImyOOY2JNgygiVA/LjodmLG8K0zSJ45gojrFME891yWSzRGHI4tIS5998k1a7zbZt29i6dSutdlvcOJpGyjR55cgRZmZmyFgWzzzxBCnLQtM0oigiAjT5mZtHRti7ezfvvPsuH5w/jx8EDA8NsbSwwFyhQL5QoL+/n4GBgRVcn7sFd7XBR1FEu92mVquxtLhIo1qlVa8LAwKiMKSQzZJOpbCkgRmGkYQHypjDMIQ4JghD4jgmjCKIY+GB5d+iKCIMAnzfZ8lx8IMAx3GYmZ3Ftm0qxSIPPvgg+VwODTB0HU3XQdNA03j7yBEqlQrPPv20uHmiCE3X0TUNLY4JOlKZ2VyOp558kpMnTnDm7FnSpsnWrVtp1mo0azVqS0vMzsxQrlTYtGnTdclqnybclTF8FEU05IJwaWGBerUKcUwmncZKpdB0nSAIMFMpyqUSxXwewzDQDUMYehQRRBGdEXEcx8RRRCQNP/B9oigiCEMc18V3XbwgSAy90Whw7epVnDimkMkwsmkTxVyOYj5PLpfDljdF1rIS2nDyWfKnhgihDF0HXYcoImWayXGCkP84cfw4hx9/nLGxMVq2TbPRwPE8coUC5b4++vv7GRwcXPU5n0bcVQYfxzGNRoOrV69SrVZxHQc9CMik02SyWfLZLJlMBkfSdFOplEgNdiEMQyJ52eKOGD0MgsS7gzBMDZGfj4EgCPA8j5Ztc/rUKYIgIAhDtm3bhmVZpFOpRJlJ0zR0XadcLFIuFAjlk0M9KUJ5g3UuRIMoAvk30zRJpVLohsE7b73F3Pw83/Xd300ukwFNw/d9FqpVwjCkPDBAQYY6lUqFVMei+tOGu8bgW60Wly9fZmFhgdj3MWS6sK9SoVIsYqZSaECj2cT1PDSgXC6vymyEUSRy8NJbh9LTRx3xu6HrwthME13TCKMIz/OIwpBavc57x46RzWbZsXMnR48c4fDhw5iplGj8kE8Qz/dpOw66rjMgF5vZTAbiOPk8PwwJo4g4CAjUjee6K9YQAH4Y8sbrr1PI53n66acxDEMeakzbcag3mximmXj7crlMsVj8VGZ1PvUxfBiGXLhwgampKQgC9Dgmb1n09/dTUl+qpqEBnu/jeR5xHK/4wmPA9zw8z8OXht5pVLphkDYMTMNIvCpIg2q3xQ2kaczNznLq9GmGhoZ44IEHqNfraIjWPtM0RboyjjFMUxju0hJhGOI6DlOTk1iZDJVymWI+L7w4ItWJ9MhBGJLLZgnDUByn7xMEASnD4L777uPI0aOceP997tm+HSudJpVOk8tmSZsm1XqdmYkJlubn2bxlC47j0NfX96nz9p9qg282m5w+fZp2o4EehuRyOYYHB8nlcugdhq6gWusylkXKNPFkCNLdrZQyDAwZMpimiYaUDZPeF8D3fdrtNlEcC2Ofm+PkqVPcs20bBw8epN7R76prGoVCIbk5wjCkUChgmKYobGkaLdsm8H1mZmdZNE0q5TJ5WYnVZLgTxzG6pqGbJinThEyGWK4pstksCwsLXL58mc1jYwRhiOY4yYJ8oL+faq2G7ThcOHuWgaEhPMdhcHj4U5XN+VQafBRFTE5OcunSJSLPI6VpbB4fp1IuJ9XPbriuK2LqICCVTlOt1ZbDFIRRpuUCUoUpCmEYiphbxupt28ZxnCSr02g0OHn8ODt27ODgwYMiFo9jYhCxOICmkcvl0DQN23WxbZsgDDFSKSqlEuU4plGv02w2CcKQucVF5peWKBeLydNIA2KZPVI3nibTminT5IH77+fq1avMz82xafNm8fTwPFzPwzAMrHSaKIowDYPFhQVc26Zt20nh69OAT53BO47DxYsXmZ+bA8+jmM2yZcsW0paFrlKGHYilB2602zTbbQxdx+jw6OlUCiuTEY/2jhvANAx86VXVfvwwpNVqJRVQy7JwbJu33nyTsbExHjpwAIDA95OUpi7fizT8bDZLFEW40uhz2awoTBkGfZUKpWKRZrNJvdEgCEOWqlUWajVKxSKVUgkgufE6DR9E6LR961YuXbrE3r17CaIIz3XxfJ8wDMViXK4F0nJNMXXtGs16nZ27d1OuVD7ur+uW41Nl8AsLC1y9ckWEML5Pf18fmzdvFuGLLPooqAxKEAQ0Wi1qtRpxFJEtFkmZJul0mrRlLRtMVzEJTcPQdZGiRIRDjuOAzK7kczkcx+HVV16hv7+fRw8dEnl1GWIAyeJRQX1WLpdLbsS2bVMoFsW2miYWl+UypVKJerPJ4uIioe8Ljk+zSX+lIkIQTRPcb7kIVuHbnr17uXLlCteuXWPr1q2kTZMojnFdF1fe6HEc07ZtUqZJFIY06nVOvvcee+69l8E7nKD2qakxz83Nce3KFbxGg7SmsWlkhE2bNokyekeaUCEIAhqNBvVGQ/SSxjGFfJ6+vj4KxeJKY++ACj80li9eq91OjN1KpymVSoRhyCuvvkomm+WJJ55IVMdiTROFKkRxqRc0TSOfzycLxmazKdYCkIQtURyTy2YZGR6mr1IhJeP9qZkZ5hYWCGTqNJIktkje8IVCgdFNmzhz5kzyebqmkc1mqciag2maZDMZPM/Dtu1kAfz+e+8xIZtP7lR8Kgx+dnaWyWvXiOQibGRoKDGCWIYXytiDMBSGXq/jSZVeTdPI53IUSkUWnYXEsDoRIwyt87UwiqjX6wS+j2EYFAsFCoUCURTxyquvEkcRTz31VKJJo0KXcA0P33mcyuh1WQRrNBpJ5TYMgmRfhmFQKpUYGx0VN4lh0LZtJiYmViyMO2P67du3U6/XV0p8SKeQTqdFWrJQIJPJEAOubWM7DkEYcu3yZS6dO0e4Tn/u7Yw7PqSZmZlhdnISPI9MOk1BpfjS6RWS0mEY0my1koxLjMjGGKZJDByde49/8tKXCOKA/kw//+yFX2NLcXMSvsAyXwXkE6LZxA8CdGnsyoCPHztGs9HghRdeSMr2qpgUSGPVNC1JX65AHKNWGbqmYVkWvlxc0mqRz2aXb0ZZXVWpzKHBQWzHYWlpCT8IWKhWabZaDPT3Y3UIQY0MD5NKpZiamqIk436VgtVk1sfKZBhMpVhYXMS2baIwxJZZq1Qqhe/7bNu164YEpm4n3NEeXhl75Hn0lUoUpFRdLpcDlufJ2I5DrdHA831ixGJSpfWUksDvnv6/CGLx+6KzyF//87/JVy9/PQlfOj2+5/vUGw3CMMTQdUodxn71yhUuXb7Mww8/vLJwJRfMvjR4XdcT3k0kszbqZ9wRimiaRlZmhlzHSZ5KyGPSu4pD2UyG0ZERKsUiKcMg8H0mp6ep1WrJNrphMDIywvT09PJ1kp8bhqFYY8gCWn9fH/lCQeT7EY5jYWmJRr3OpbNn11ViuB1xxxr87Ows0xMTRJ5Hf6VCqVwGJLfENIXxhCH1ep2WbRPHMVY6nRi6YZoQx/gyY9KOWiv274QO/+SNL/OlN/5XmsHywDHFg4kQGZxisZh46mazybtHjrBt61a2bt268oBl2lKFM8qAOm8I6Aql5GumYZDJZMQitt1ekWlS6chO6LouiGEjI+RzOVK6zmK9zszcXEIyGxsbY2lpCdd1k8UtLD+JFPVY3XDZTAYrnU5CrGarxVK1yuXz59ftwb3dcEcafLvdZnpiAnyf/kqFgf7+JNWXSqWIZOtdtV4nCEN0GQ+XVLZDLgCDIBBflqZRyfWJnccxURyha+LSfPXy1/ibf/55Tsy/T8u2aclpe5l0mkKhkHDLoyjizTfewMpkOCDTj51Q4VUSv68jna2eKJ2V3oxMjcZxTKvdXrEAR9OE4Xd5+1QqxdDQkODHSO791NQUruexaXQUXddFBbrjpullvJZlEctjTqXTGIZBLDM709PTXLlwYc1zud1wxxl8EARcvngRLQwp5nIM9PcnIYD60hvNZuLV06kU5XKZjGWJtJ5hrKiGgvDUfZmKeKxDYuwKU60p/r9/8Y/5vRP/D2Ekqpb5fD7xigAnT5ygWqtx+NAhzK5yvFpggqAcw9oZmk6oLVTMn8/l0HSdMAiwpVBrt3fvlVkqlUoMDw+TNgziKGJqZgbbdRkYGEjCmuQ4YdWNo8m1hK7r+J6HZVlY8okThiFXr1zhfIeQ1O2MO87gJ69dA8fBAAYHB4Flb+h6HtVaTSwkO7y68sKJ55T/D2Q7nmkY6JrR00sC5MmTilN85cJX+PLR/41qVFvx+sz0NOfOneOB/fup9PX1PG5NVmcVBUCTnVKdKcMVPL6O41B/1w2DguTLOzJduKpmvMY5ZGRsn81kMDSNhaUlrEyGpaWl5DMiSYRL1gYdx2Ol04LCEASEsjCVy+USbz8xMcHJ48dv+9lTd1SWZmFuDqdaJQhDNo2MLKf1JNfEdhxMwyCdz4uUnqw4ropxNY0IGV5EEbphYBm9SVJZsmRiwSVp0+bIwlH+5p//HH/3kf+JF8afp91u89bbbzM4PMzmzZsT/kzSDSVpvDGSX2Pb6LINsNFsQhyLn53HKY1W8XFM00zWAGqRGkjmZaVUEufY9cRQ/J5OGKbJyMgINdnNlU6nsV2XerNJvkcTiK7ryYJWl2sjdD1xKJquk81kcCXpbm56muNBwP4DB27bNsI7xuCddpulyUn8IKBcKpHNZpPFVaPZJFaLQcVhV2m2dfapGq5N08TUVxt8hgwFCujouLhoaJQoYfgG/+fr/5rjYyd5VH8Yz/fZtXs3tuTRK5qABiLFqOL3ICCOInTZ7pfMqlS/qxSoDIEi1cnk+/hSHQH5Hs91RdZHpgk1XRdNKroujFN2TKmbqxPlSoVUOp2kaC9dusSOHTvIrJFi7OzuUuehoBsGWcPA0HUcx2Fhbo4Tx45x/4MP9qwzfNK4Iww+8n3mrlxJOB79fX3C2MOQmizImOk0Bel1VLfSesYeBoEwBtkml9JNdHRMTFKkyJKlFJfQ0PDwCAkxuy7XK5Ov4Mcu37vve8jncsLY5DHour6i2KNpGs1Wi7RsNslmMmJboFQsUi6XkxsF+WTwg0Dk2XVdcGpU+jKOySE4/p7nCWOPYyJJYkvCIXXj6TqmpC+bsiMql8uxdetWjh47ht1qMTs7y/Dg4CpmZGfOX7ExzVQKT8by6nVV92i128zNznLi2DH2Hzhw2xn9bW/wURDQmJvDcRyiOGZoYEAsnmT1MZbVxmKhQLPdxnVd2o5DeR0edwyieUMaSNu2sYIM/fQDkCJFPs4RxeBrPi1aBASEhEREhITi/3GIl/W477771myWWBXTym6kXgvDbrpyDKKJRNdXFI4AkHIfrucl1IBQpmKTziiZT4+CAC8M8To+U5eFr2KxiOO66JrG7Pw8gwMD5HqEN6HvJ7G7aZr4vr+iJVBDZHPCMMR2HObn5jj53ns88NBDt1UjyW1t8FEUEbRa1Ot1wiiikM9jZTK4jkNDaqmbpkmpWATJLfE8j8D3cRxnlbeKIeG3V+t1XNsmLbexdCuJJkxMmrRxNJsaNeLVS0MASpT4yw//5bWNneUMizofWF0sWgtJanKNhWA2m8X3PAJp5OlUKmkGUVAyHkEYioYQqZWjaRr4PoVcjoWlpaToND07y8jQEHlZvINlMhmIop5qTew8N3W8lmWhxTEt12V+dpYL586xY/fu28bob2+Db7dxWi1cxyEMQwb6+mi328nFtywrqa7GiFRfLpsVmjK2LR7fui6MPAjwVIytaSIO1bRlnRlLo6bVKWtlWmETn5AG9Z7HlTNzHOABPrP5v2bH6D3rnkNi7HIhC705NGu9dz0zMXSdbDZL07ax1fl2GZYhwyvV4xorLRvJ/c/l80xMTVEsFqnX6ziOw9WJCQb7+ylLJbS2lBXUdZ1iPk9NVpmDIOjZEZXOZIjlk/PK5ctk83k2jY3dFkZ/2xp86LqEnidk56KIYqGA5/tJV1I2kyGfzydeRhlTNpPBc11ats1ks4mVyWDK1BlxjG4YpGSjQxxFFEslUqaJaZoUKBBHImXYpo4WiwYNkaoTX9Zz48/yXcbz1OfqHHzg4fVPosMzq/x7r0Xkuug4t16wLAvH8/DlU60zHFGL4c4aBZDE85ZlUS6Xk1Clr6+PxcVFXNdldmEBx/MwDYNIPj0KsrUwJSvZQRSxytxjodOTTqchFj2zH5w9SzaXo2+NlO2txG2ZOwqDgLDVSpog4igSagKSgluQaUfV4KDMypclb19mNfwgoC1TfrlslnKlQl+lQiGXE1kMSDIPqSiFEeugQZ06MTGapmPqBoZugAYRMVdrV5m9Osv+++9fHVd3oTMQSbz7h0nXdRC61t5ESzJWjuOI6rHi6MjFb0IMAzR180uohWcMFAsFtm7dSqWvD8s0mV9cZLFWI5AqCbbjiHhfNq6op2RyvtLY1bFbkpLgui7nz5xJhrZ9krjtDD4MQ8JmEzRNxO6SLqBISoVcjoxlLRt7HGO321RrNer1Oq7rouk6BUnVzRUKCYdd8VeS/DjiAnieR44coNGkSUiYHM+evt2AqL6ausHF5kWm87Ns2779uufSaabrUYKv9351nt1QRSvVwgeivXC94k/nTQ6SNiCJaer1wf5+crkcmXSa0PfR5RMhCENsGT61pfHTcUN1f2ocx4n8SG1piQvnzyfX4ZPCbWfwsW2LriApWOS5biI+mslkBN1W5oXb7TaLS0s02+3kQlrpNMVikf6+PgYHBgSlAGEIjUYj8X6quBPFMa1mkweGHsBIGXiI3PShkUf4V3/pn/Mvvvv/YEtxefBASMTr4etEcZiECZ3hggYiDIlXLnUV4evDFmTUzakKWSotGXZUZiNJ51XFqusxGDvXBplMRlRupcH7QUCz2RT0iWyWomSUZqS31nRdNKBEEY5ts1StihqBpiW9Bwlk+JbLZtENg8lr11ZQGT4J3FYxfOj7RL4PcYxj2+JRGoakUinS6TT5XE7I40kvA8KrmLouGqzT6aTiqB7lpWIR23Fo27ZQ/qpWVzSGNFstwjhmU2GEf/Y9v8q7s++yo7KDvX17kuP66/f/LL/4+v8iuo5inQl7kj+/9FW+b9v3rjj+FaGD/JsqQKkbspMDrzy0Muru96guJ2Ruv/MG6g5yDHkNPMfBcZzrNl1rsj0xnU6jaxq2bdNqtUTuH/Ek2jw2xuLSEm3HYWFpieGhIUrFosgKhSHtdlvcIO12kuPvJsWpp2shl6PebHL5woX/f3tvHmRXntV3fu7y9i2Xly93KbWWVNpKpSpJtalU1d2AGZt2Nw3YpgfwOALGwQA24B7CDgfGDgiCgcHjYNxBuG1ozNIDRNF0NU1DdXetWrqlUmmp0r5lppT79vbtLvPH7/e7ed/Ll4uqJNWmU6GQKvO9++6979zzO79zvuf7JZVKvW9D4R+oCG9LJ9Y0jaKstITCYUyJ2yjKiF6VjLu6YRCPx0kmkyJS+ZwdFp0iEg6TSiTEDCpQKJfJFwoUikUs2YCKx+N0xzL8gw0/0ODsAM8OPMOG2JB8iMTP/vCdP6JmtxYbbuWYauPoz+H9iEj1Ptf377VubdUxFEDOUtw5q71P1wUjcjjscdKr0qJCgnZ2dBCSA+wzs7OiqWcYxKJRgZOXD06tVhPfmdxDNZuu60TDYUrFImO3bq1JqPle2AfG4e1aDWwbDbGsZhcWsCyLZDxOKBBgIZfzorpuGKQSCdpSKfFltABaNTuLaZqkkklBhYGg5SgUChQKhVXJhjRgP483/Gy6Ms3Xrr/Y+g1NObQ/p2455bQGW4vzG7ru0Yj4Ze9bmWVZQlChUMAwDK/EGE8kROqiPlfTSHd2egPdM3NzOJLzXpfVmEQ87rE62JYlysKlUqMUkCZoToKmyeT4OPPz8+8Ljv6D4/AqRXFdFubmsG3bY+MqlEo4tu2N0rWlUgRlzuq35ZxdmRpmiMuNrIvAjCvRg2Kp1DL/Hb11i3S5k13tOxp+/meXvkKpXlry+mbzf/HvthK9UqXG/0ApxgLFVNx8HrVajXw+T6FQ8KKskuaJyepVsxmGQTqdxpDw4Nn5+UVcjWxARcJhEvG4N/Jn1evk8/klkTwSjQoG5dnZNamT3237QOTwdq2GK1OLSq0mIAL1urg5cvo+Fol45TdlmqZ53OxrAYspK0sKipisDVerVUFKVK2KCSBdFzQdgQCmYXDxwgV6e3r4l1t/hp99+ee942RrOf7iyl/ykw//RMPx1SZTEaxWq1UKxSKapnmgL0cOk4OY3ipLFRBD19ElU7GuaVTKZTF321SCXc7UHGxF5vIqeqsyrbf6yKZbMBgkuMIwirKAadLR0cHs7CyVcpmcLE3WfVUXXaIng4EAJTn0XS6XqdXrApYsN7GRcJjpqSlS7e3EJDPz/bIPhMM7lQq6YYiNULFIIZ/Hsiwv4qTicY/motlUhUTlyKtZpVajLslSo7LEGQ6FBByhWqUuaa6Vw0xOTLCQy7Frzx462zp4uu8p3hg74h3vzy/9JVuqmwlYASF2VqlQLpW86KpWEn+JUf0cxMb03Llz/gtqPGHV+DIMATyTwxfhUIhwOExIjt5Fo1HiiYQAd5kmtXqdumQVM30O5T3MclxP3cMln9vCIpLbciGbpSBToZAqEfveb0jcfq1WE11ay6JYLBIOhQgGgwQCASqFAvNzc0SjUQGcu0/2vju8U6vhytw9n8+TlWN5ZiBAuyQVWm05X25wY8lnuS4licEJyoijzAwEiMs8tG5ZVKpVcrkc165dIxqNcvXqVc4Wi2wqbOQcb3sISsu1+OvRr/GDqX9AOBwmLpf1cCRCKBQSzicjfTgSEQ+xhPHm83le+va3OXToEIlEQkR+yUiswF/ZfF7QgOi6AMZJDpy5+Xkq5TLVeh3Hl4ZFIhGiEnMUCASIRiKkJZ9mIBBoGU0VQZSCAa9k8XicWq1GVm76Vde1udyqpqQM06RUKoloX6lgO45X4pyemKC9o8Mjk70f9v47vJSPyRcK5CXHSyAQIBaPC3ro1RzZB4H1j9K1smKxKEp9hkFIqWtIq9VqzM3NMTs7y+zsLPPz817XUg0/RCMRdnfuYmx2jLcWznjvvWWNMfDQIJlYl6fx5EGFJabEkila2IcwVM5nmmZLMQLbtr1KigLI1eQcriO7n7hCrqdYLAqBtGKRUrnM7MwMFelguC7RWIx0Rwed6bRgTk4mGyK8msJyV2kMOa5LIpmkUq1SkVTbrTj0lZmyklapVqmUy4I23HGISkrBYqFAOBy+b7CD99XhHcfBtW2KpRILc3OiRBYMossp/bUss64PTaiWZtd1G/J6WKTCRu4HFhYWmJqaolQoMDM7K6DGiE1fZ3s7D2/fzujt29RrNT7xiU94tBqWbdOZ7eTky6cAMDCwsXnx+tf5iW2fb1l5KJRKuLaNJVMlda4FudoUSiU0FXmlE6smU1GhQuXvm0cBdV0nEo0SjUbplWqCqhKUy+c94YdiqcTc7Cy3bt0SkGqZk3d2dnrErxqL9flW5m+etbe1CV6eWo1CsUj7CryTmiYY2TTE/slC9D9CsgMbjcWIq0rPPbb31eHdWo1qpcKcdPZoLIbrOOSKxbVd/DIRXdM0XB/FnuO6FAoF5ufnWchmmZqYIFco4LoubW1tpDs7eeihh+iQy6tacc6cPcuj+/Y1RMKAabK+cx3PbX6WF65+FRBO/9LEt/gHm3+A3nCPt2n1mkpyxA9oYEJTgDLHtr1/t7gYLy/3KL41MYyupprU5zVbNBLBtiyi0SgbNmzw9jrz8/PeSnb16lVqsqJy5MgRevv66OnublhxlszbImQ7E7EYC7kc2XyeWDy+7OZXwRmCgQC6rlMql3Ech3K1Sl2edz6fp6Ojo/U9uIv2vjp8tVQS9VjbJhyJkO7sZHx83EPnrWir5JpqaHpycpLh4WHGx8ep1+uEw2G6MhmGNmwgnU4vG5muX79OMBhkcGCg5e8/v+2f8Y0b36RiV7Dlf3987U/5D/v/fdNput4oYSqZXMSduIukqtFIhHg83tiIkiuXirwqbVDox7WYaZqYgQBuvU61VhMwaF2ns7OTzs5OpqenmZmZEU2hSATLtjn91lu4rksqlaKnp4ee3t5l1UDi8TjFSgUXWJifJy2Hc1qZcnpTE8P1JVmnr1UqFGS1yrKse57Lv28OX61UKMzPU6/XCUpFDsDr9q2Vwm2J27su0zMz3Lx+nbHxcYEDiUbp6e1laP16MpkMtWqVfLHYUL3wW92yuHnzJhs2bFi2ZNYebueHN3+WP7n0p97PXr/1Bhc2X2R7xzbvZ0qYWJMyOH5TgC/TB/7ym0e41KLf0OCAKzz8oWDQ05by7x9GRkY4deoUmUyGYrFIJpNh1+7dVCV3za3RUS5cvMjb77xDLB5naN061g8NNQ7VaBqpREKkNvU6+WKRVCKx7LmovYKh60SjUa8sOz01RTyRoFwuk1jh/XfD3heHt22bnMRbG4YhSEClzIvCXqyY0vi+YHUTa9Uqw8PD3Lxxg3yhQDyRYPv27aRSKaGIEQiQTCTE0izTHWcZRxkeGaFer7Nx06YVr+NzW3+Yr1//Otl6Tp4L/Pd3/oD/6+nfXIzkqum09tuzxLSmf2u+dM374GWuJRAIYMg537osCFy4cIGLFy8ytGEDj+zZwze/+U2Prc00TQbXrWNwcJC6ZTE9NcWt27e5cPEi5y9coK+3lw0bNtCVyQh5TTkmWCwWyefzRGTpsfWFCGiFqupEwmFKpZLQxF1YwDTNj6bDz8/O4lSrOFKGJhaJeAhJXHfldMb3xboImuwb168LqXbXZaC/n0cefZR0ZyeWbZOTSh5qMELhWRp4V9xFwlQXuHb1Kv0DAy1nO/2WMGP8k4d+lN9/+0vez87MnOHU1Fvs6xbDId5Y37tprizjxEsaUCvBgWX733YcypUKZ8+eZWRkhB07drBl61Y01/UUQFSwkW/ENE26e3ro7ulhz+7dDI+McPPGDV4/coR4LEZ/fz+Z7m5RUpVlx7mFBTLp9LKpjZ+ZwTRNwpEI5VKJ26OjhCMR76G8V3bfHb5cLmNL2G8kEhHUbYEA+DZ5qw1JuAgi1XfeeYeZ2VkS8TgPb9/O+qGhhuhSLpdxwKuHK/M3WrxuLYDrMjk5ST6fZ++jq0wzyfP4Rxv+IS9c/SpT5WlvKup/nP8DHs3sbahrv6fxtqb3rqXj6rdgMEg+n+fM2bNkFxZ47PHH6e/v9zbTVr2+hC1NfY76LDMQYNOmTWzauJHZuTluXL/OlStXuHzlCuvXrWPrQw+J+VqJpWmJhvTtSVSHNhgI4IRC5ItFFhYWPBXBe2X31eFd1yWfzQo1PZnXRlRO6I+4KzjH9PQ0b58/z9zsLB2dnTzz1FN0ZTJL3mPJTiOuu0Rp2ut2NmNvNI2bN28STyY9Cj/x49bnowEhM8znt/04v33q//Yc/vLCFV4fe4ND/c94efgdTTo1nd8Sh29KYVZsFrku5XKZN998k3Klwr7HHqO/r897vyXZy1rtITxYsn+TrGnepnfz1q0M37zJyPAwIyMjDA4O0tHZSa5QEMJxTdfsnWXT+YZCIcqVCgtzc8y3t390HL5YLHqY94BsMSsWX7/Dt3KNudlZ3j5/nqmpKdrb2njqqafIZDIeXV2zlcplr66+RFpmmQmdar3O+MQED2/f3tLJFWdM8+++f/2n+MrlP+d24bb3sz88/2We7H1y8aF5Nw5/p6/3PcCKMWF+fp5jx45hmiaPPf44Eansp65BQSBaOjwr7z1Mw2BoaIhNmzYxfPMm165e5fbt23R1dxMKBulcpszouILfxvEFlGg4LJqP+XxLxom7ZfcNLek4DoVCAV2OjAGL0V29BhryaRCTOMePH+c7r7xCtVzmiYMHee655+iWm6ZWq0FdDjW3+gyQzifTDf/Gdfz2bRzbZnBwsOU1NOPXNU2T5KsGP7ntJxocdLRwi5dGXmoY3r5jWwb9qZzZ36DyU/up1HB8fJzXX3+deDzOs88+SyIeF+VQHxRB4eZbpTTyIlfMxxUN+cMPP8z3ff/309ffz8T4OEePHeP69etLZgPUe8ShF68sEAyC47AgewT3yu6bw1erVRyJ+zCkgG9DdGfRgVSEGhkZ4aWXXmJmZob9jz3GJz75Sfp6e1eueLhiUt4FQuFwy82ifyzPX9MeHh2l6050SVV3UtM41P80D7VtAXeRHPXLF/4nFau2eG1uI70esiPsH/rw//HGBF23wZkbcC9ua9acq1evcvz4cXp7e3n66acJSe1ZXdcbRBU8FogVNujLwZq9CpR8IEKhEI/u3cu+fftoT6U4ffYsR48coSQpxtU1ecf1PUi6rhONxcjOz5PLtaZHuRt2Xx1e8325rZzKcRx0TcxlHj92jBMnTtDd3c0nP/UpBgcHW9705p9VJdmQgqEuZyqnVg5fKpeZmppaNrq3Mn8TydAN/vnDPwUaHunpbGWWV2+9CizSc6iNoLdxliVG7wHw/xEHb1jFtKbP9l7j+/eZM2c4d+4cW7du5fHHH/cidFC296163XO8snTGle6VOv8G8z1ozSleurOTDRs3smXLFuazWb717W9z48YNca+bztX/3lAw6AHkWk1N3Q27bzl8tVrFldHdkFyHQMOXads2165fZ07OnT5x8CC9vb0rH7hpA1eV0T0SDq+YRmiSpkM5/OitWxi6LjZ079L2ZR5lT3oPZ2YEsExH5++G/56n+p6kTWu78wMuk9IsZ7Zt873vfY/JyUn27t3LUBOzgmEYGIaB4wrlk1AwSKlcFsFntZRLPqzeauR7KJvPLxwOe4CwdDrNrdFRTp46xcitW+x95BFPkghoAKwZci62VCxSLBZpuwe6sPclwluWJYY8ZP4eaBrLA8B1OXvmDDOzsziWRUdHB9VazSP+X+vnWHIIPNwCfei35gg/MjxMb1/fHbW2vSvw5aT/28M/5fu9RtEq8u3Rby9b6fE3plaEQbf4bNf380qlwmuvvsrMzAxPPvnkEmdXFggEUOwGICK83wFXMn8AUfX05aDZCo5gWRY7du7kiYMHyWazfPvb32ZOctLLAzX4QsDn8PfC7ovD12o1NIknaQUbsG2b49/9LnPz82TSadavX0+9VuOtN9/kG3/zN3z7O9/hbVlzX647ClCpVr26+2qbRJViOI7DQi7HQjZ7R+kMLOajrm95396xjSd7nhCfIW/v3428xFxl3svD/X9A5rYs5uxeDu8bDfTn/8qUo+XzeV55+WUq1SqHDh0ik8kse87BYNBzeMcVbL+RNTo8LD7kziqrTygYJBKJ4ALZXI7u7m4+8fzzxONxXn/tNSG1o47p+66CgQDlUsnL+++23ZeURhF1AovE+tJq1SpHjx1jIZtln2z2GKZJX18flUqFqakpxsfHuXnjBpcvXyYQCNDd3e39Uag+VwKRcN01bTr92kyjIyMEpVjAitfhux4vqrlCZlLzOf1PPfyTHJs47jl8xanwlUtf4V/u/t/XcLeWfh5NUdTv9JMTExw7fpxoLMYTTzxBtGkMUm16lekynXQkt3ypVFp76iDPQwHiNJbvILtAPBajKBnkLMsiFArx9NNPc/LkSY4fP86ePXvYuHGjuHeaBo6DYZrYUqPrXth9y+Hteh0DX/lLRpc33niDer3Os888QzgcZnJqymvWhEIhBgcHGRwc9GCtE5OTTE5McOvWLQDa29vpSqdJtbcTCAYFQnANaYkuS5O2bTN66xb9AwNLiEidFjV3YIlDNb9iKLmeTw5+gjdGxSigg8PXb3yDz2z6DD2xlR8qv602lD48PMzJkyfp6upiv09bakkjypd+gEhr6pYlUsY7SGnEyYg9ky0LEMs11FyJywkGAlTrdYqlEm3JJIZpsv/AAd4+d47TZ85QKhbZsXOnV6FTxyv4RJXvpt2/CF+vY8ihYRBpzuuvv46uaRw+fJh4LEZNVlcaho2lKY6Uzo4OdmzfTqVSYWJqisnJSa5cvUpVqmH3dnd7GI+VEJeGLkR98/k8+Xye3bt3L82T3wMc4H/d9nm+O3oCEA5fd+v88cU/4Zf3/eLaD6LuQXPH0nW5cP48Fy5eZGhoiN27d698rr5qEsi0QQ6FOK67aoWm8VDiwVFsBc0R3p+KAcRiMaoLC5TKZTG1Jd+/a/duotEoZ99+G9M02bZ9Ow6LK29FMkbf7QHv++LwVUmfp+ggLNvm+PHjWJbF888/74G01MUpSuclebiqyGga4XCYoXXrGFq3jtKuXYzeusXszAzZhQW+d+IEmqbR0d4uMN09PSSlSHBDu17TmJmZwTAMuqRA2p3actj0nlg3nxx8ntdGX/f45b81+m0+t+WHGUquX9OxW0V4x7Z589QpRkdH2bVzJxs2blwZWtDCNF3H1HXKxSK4LnGJUFwrRsffv1ARWfUWms8lLEXUVJoS9tX7N23ejGVZvHPxIolkkt6eHu+BUkwSH0qHV0PGajrn9OnTzM3N8cyhQw2IRIVidBEVl5YR2ofmA8AVM51tqRQ93d1Eo1HK5TITExNMTkxw6fJl3n7nHcKhkMj7e3rISOl1wzCYnZsj3dm5om7qcubV0pdxuH+04R9y/Pb3KDiCf8XB4cvn/4hfPfjvW76+2bw6t/y7Vq1y/Phx5ufnObB/P/0DA56U/Z2aGQhQLJXQdV1IcDbV1f0NwKUn5nrVJTX6uFwxQVfY90KBQqnU4PAADz30ENlslpMnT3Lo0CGiUg60Ltnl7rbdF4c3kF+a63LlyhVu3rjBo/v2tcRa6FJHda0ss5ZtU6vVcH2lyEgkwoahIYaGhgRb1uwsExMTTExMMDw8jCanfpKpFPMLCzy8bdsqn7K8rRQVE2ac5wcP8+fDf+H97MjEUS7OXWRbx+qf6W/BFwsFjh49Sq1W45lnnqGjs1O96F2dt6p3x+SkVavPdWmNO1LiCM4Kju63aDQqaMzlIEpDINM09u3bx2uvv86x48c5+ISocNlKNPou2/2J8Lbt0TWcPnuWrZs3M7S+9bJuyM1kvV5fsd2trCY5ZoKSSNXfigexqnR1ddHV1cWuXbsoFotMyo3v9WvXwHW5eu0a5UqFnu5uujKZOxsz0wRrrsfuK/+2JenrU+knee3Wa2TtHJr870/P/n/84t5/5U38FAqFhnlVddyyZEXO5XKcPXOGQDDIU08/LTAxigFZ1+FdUFCbhkGhUCAWjwtalGWuuRn34rLINrZWC0iVFUVq27xyG6bJwQMHePmVVzh39iybt2xBN02KksX4bto9d3jFTGCYJpcvXyYejbJj587lT0gO+lbXSLZZq9dxWVSR89ryy2ziYrEYGzduZOPGjXzvu99lbHKSrnSaqakpbty4ga5ppLu66Onupqenx8tvQXLXSz0lW+oc1Wu1ZaNcrVbDJMAPDH4/L9z8qvfzqwtXOT9zgYFgP0ADRsZv9XqdmdlZbly/TjKZZNeuXQCerivIPYSmYSrGMl3IV6624XYR6NV0V9eaZkn9vQMFKb6TwBCNRj2iKr9YtLJINMquXbt489QpMtksXZmM4BDq6lrzZ6zF7rnDq45eUdJh7JZf2nIWCgbRYU1qEZZti86qJtgE/Lh2/2RNS+d3Xaanp+nOZNiwcSMd7e0UCwWR+kxO8vbbb3Pm7Fmi0SidnZ10dHTQ1tbWSHftz3sRUVDppMJik+dTWz7Ji+NfZ7Y6hyv/+9ORr/AfdotcPhaNiqiNL51wHG7euMH1Gzfo6elh9+7d3meqVQQkUM22aWbEVOeh5G2MJuXAYrGILaWEVuOTpyl18TD0dzCZFIlEBKxBkly1mibrymSIJxIMj4zQlcncEzzNPXd4NbZ348YNUskk6XSa6jIXjOt6qUmtXsd1nGVx5K7rCgQmeNqj/kEFbwleJtItZLOUKxW6urrQNcH5aAYC9PT2ku7qom5ZzEtipqnpaUZGRzF0nY6ODjKZDJnu7kVBNdddErFsx/FQiclokn+y/cf43dP/j/f7y9lLnJwVZUtdOqR3bY7Dmbff5vqNG6xfv549e/Ysiaau6+LaNnWpzqdWHqfpj9+ZTV33ONwXFhYAwTxgScFk71636CArc2zbA4EZkh5xLdBnDUHtYUmuzebvXzXCNm/YwJtvvcXM9DT21q2tD/Ye7L5E+OnpabLZLE/IDUm1UiEYDC5hDVCpiaHraK5LpVZbUiN2fV9GTe7kQ1KEuFVi4Xd3r+uoaYyPj2MYBuFIhFyhQLVpM2UYBj29vQwMDGAYBiUpuDs5NcWlixe5cOEC0WiUbpn3d3Z2NjZhfLmvpml837pP8RdX/5JbviGRr9z4C76PTy65XydOnGBycpJt27bR19fXUuZS0zQ0w8CUv/Ofu+psO44jVkG5AbQcB6tWg1qN6ZkZghKi7cqHMxQKeeLHy6VEilrElCBA/3eyElWfAvSVSqWW6ari/E+n03R2dHD9+nX2HzzY8ljvxe6Lw09OTNDe3k5vby/FQsGjXVsy9yhTkEAoREWSmyqH9y/hqopjyfZ2MBhcOX2R5kqUYL1W4/bt26RSKS/vdxzHU/MzJWtwA3Q1FKK9vV3MbtbrAvIwNsbo6CiXLl3CNE0ymQzdMvdXy706gqEb/OT2n+TXT/yGd8yx8hiXtSt8Qjp9uVzm2NGjFIpFnnziCULy2pcFnsnjq1Lu4m3UvBVBPQaKq9KScpX5XI5YLIZVr1OuVqlUqySTyWX5J5Up2Xl1fL+Tr+b4oVDIa1r5qzW2XKUc1yUaDrNp40ZOnDzJ9NQU23fsWHKc92L3xeHn5ufZsnkzAOFolGqtJqjv6vVGhgJ5k0LBICVNCm1Jp2xuwqjNqhkIeEux1pTWiEMKctSqZAZWeXIul2PDxo2CyFPCUr0HcJmBB2WBQID+/n56ent5xLaZX1hgfHyciclJTp8+jeu6JJNJ2tra6MpkSMhN2jN9T7GlbQtXFq54xzqrvw1AbmGBo8eOAXD40CESySRZOQix6njgCr0AZV5OL6m35+fnxdB7KNRA663owgOBgGAKa3J+y7JwwEvBWt0nRcPhd3qFPwoEAjiS1VgVGioS0h0wTQzDIJlKYRgGYz6A2d2ye+7wU1NT2JYlBq2RKhWRCJVymWKhgNaCUzAUCqHpuodtbxUtVO294YHxRUJH5vhVyceuzNB1KlJod2BggGQ8zrxk7PXn4h78tSmPbR680HSdVCpFKpVi27Zt1Go1pqamuD02xvj4OMMjI5w9e5Zumfd/fvM/41dP/pp3iAJ5ZmZmOH/+PPFYjCeffJKwpMiDVbDwq6USCpTlNspX5nI5avU63ZkMyURC0INXq15O7jiOd+8CpklQsj44ti0IXFnkulQpm//zm9ka/L8Lh8NUazWq1SqJeFwwCtt2A6RbQ2Ckxm4vpn93y+65w9+6dQvDNBvYYSORCI5c1oqlkhcBlanJnLp8TfOAsS03Yxos0Uq1ZAu7Vqs1VFAUj7ppGFybnUU3DNrb2rwyniq3qWXWXw9XTuetNBLZBz5MunSoYDDIwMAA6XTaE1/LZbNMTk5y6s03cXF5JLSH03UxJLLDfZizZ8/S09PD/v37vVTB3/VsNtddlOxc0tJvTuua6ugAc3Nzwqk6Orz0J+i6Hp2JJVdfpRVVlywT6rjN6d5KrMPNvP3hUIgcImCVpOKK4zgey4HrODjy3K7fuEG1Wm3JrPxu7Z46vBok3tTdvUTMKyoV+SwpkxiPxTynV8Sb9XqdQqGwhP+xLp3ZNE1vubcsi1K53FDONAxDCAjI8qCyudlZ2lMp7/NMCUldFs6gztuPkvRHMfDmNRWFhi0dry2Vore3l23btlGt1ZiYmKB/op9NE5uwLZu2epJwNER/fz+2ZXlzvt5QdlNq4H0+S6G/8iSXPX9lM7OzJFMpL0qbhoFVr2NJxcRAMCjUym1bpJ+S4lpFY78Curr+le6ZK1dC13EIyP1RpVKhUCgQlFzxpmF45U/Ndelob+fqtWuMjo6yWabDd8PueYS3WziRqlnHYzHy+Ty2dPqYVI5zXJdINOoh+pod3qsUyGW2JHnH1bGDgYAYWl6mTjwzO9uAfVc0f9YyUaqV+Ufc3Kafa4jSoj/aqgrUunXrGOjvh5Nw+/ZtarqYAjt58qS3lPf09tLR0eEJhXnHZHGDqqAa4qLvDNU5OzNDxnf9qkbfDOfQDYNIJEI4FKJar1MqlUQFyLLI5/OEpLzNWia1GkrGqrGoaZ4gmgoU6nVhyUZ3t9W773mEx+cYzb9Titm5fB5Lah5FIhFPpnJBSlTWLashrVHLYL1WaxgUCAaDQoFuhS+gUqlQKBZ52IeOVGmEapkv+37pwH6KDBDO598q+/cdzceqVascO36chYUFdu7cyam33mL//v1iFmByksnxcS5fuoRl2wSDQbrSafoHBjzAm2oAeRTWy2xYl7sOpcfaqbA4yBQFPCBa8/s0XcfQNKLRKHXLwpTnUZapYzgUEn2QFufRPAeryo+uhFI0pyvq+owmSPPdsnvv8LBkYkf8SPy/Lsk484UCVq1GQS6ZgWBQNCpsuyGtcVwhNV+qVEjIFcE0TaLRqOe4y3KtA7Nzc+C6DcA1JUGjBHe9Jo/rLk0dfA7XcC1NX0wrhy8UChzzAcD8+5ZwOMz69etZv349ruMwMTHB2NgYc3Nz3B4bQwM6Ozu9smcimfQiu6ZpK9bOG65/dhZXHkuZrutCkEE2r1qxKqsKVywaJSQrO6ogUCyXMTRN0KK0wO6rv5USiq5pBOQ9971Q3Fc11igfwrtt99zhVSRvNv/uXdcEZ3gZUW4sFgqEIhGikQgVX1rjuC7z2SylSsXD1kei0aUpUzM9nM/mZmeJSEVAv5mGgSUbMHdMmrRMhURdm/rco8eOEQqFOHz4MLF43Ot2Npum67S1txOJRnk4FALXFZNek5NcvHSJd86fJxwOk+nqoru3l+6urqXO3lSbd13B9jUzM0M0HF7S0DMMA1sTcpdLGoKOQ13hZ2T6EQ6FCErJz0qthi2JtsKRiFc5U5/vOI4YNpEVoEQiQVXuCyy5Yqj75Y2CfhgjPIgvT5XYGn4ODRUGXdNEDl+pUCmXqZTLHvqxXq1SLJepyYYViEijhjqWHLvpy/bb7Nxcg9KEOgfDNNGkwt9qjAfqfSv+3hfhb926xcmTJ+ns6ODgwYOCZWu19/sGuMORCBs2bGDDhg0C7jwzw/jEBBPj49y8eRNN12lvb/fw/ol4fEler+7JxOQkmZ4esR/wceIYhgHqu2q6fgVPMDRtiSJgOBwmEAxSKhY9mUpLCk8oEGC5UvHuRzwe96haXHlstdfyzz6rlOdDNQBiGAZdmQzTs7Mtld4AL21QFpFckKVCAWQEUCRJyWQS13WJxWIk4vHVx9papBkLCwts2bp1CTpRUYdYtr0ihsd/3it9lsqxr1y9ysULFxgYHGTfo4+umTZbHa0ZVqAbBpnubiFgsGsXxUKB8clJxsfGeOeddzh37pyAPPT00NvTIwSFZYpWyOcpFgrs3LFjyfSXqTauLVZGhQlarghgyL2YXi4L6U/LopbPe3sbV6ZJkWjUux7DNLGqVSylxeVzdk3TmJ+ZwTDNO2aSWM3uqcNrmkZ/fz9nT5ygUCiQTCYbft8KnASiymKkUh4rVk02QdpSKSLhMI7rrgpNbdWMUdWchFTE85uh6x5Zf32V8qQ69xWrE47DxYsXGR8fZ/u2bWzfvv2Oqil+otGWx5d/x+JxNsfjbNy4kXqt5kX/yYkJbly/ji7nAbq7u6nWamI+oAWNh6qzN9fTvXTGdVdcmRTTm67rZLNZKrUaOA6hcJh4LLZYiZGmKmO2Aq7RiNOZmpmhW8rt3E275ynNwMAAR197janp6QaHXy0lUOW3RCJBMZ+n7rrk8nkvf1xtJE9jsS6unCefz4PrtuYuR0Qw27ZXdfhWzu5nw7Xqdc6cOcPc/Dx79+5lw4YNq1xtC1ORdrmVpkVua/gEDHBd8oUCk3LS69y5c94qe/78eXp6eoQmk1xxFE+Pq0mRZzluWZMNPqUSvtI9qdfrlKVyuF6rgWpQtShaGKbpraiaHKhXEd4wTebn5nhcgg3vpt1zh49Go0QTCaYnJ9nsk5BxkVG4xRLqOI7Aa9s24VCInr4+FhYWRO1X6nvmCwXRsFjO8TXN44tRls/n0QzDg/U2WzAQ8NS479jkslwplzly5AjFUok9e/awYRkGsNVMPTytkJKwCH3wPr7F+SQSCRKJBJu3bKFSLvPNb36TVCrF7Vu3uHb1KoZhNADedEk/aDsOAakIUlUDNsukM67rClxUtUpdQg80TaOjo0N0aeVDgOs2BBGF6VERHhY3rErB+10FilXsnju80gwauX2bPeWyh4N2Vcu5Kf9VtNqqJR2Px4lGo1QrFdGscBx0SbpZq1YJyNq7P79UN9DwRV0QDh+PxZZNE0w5RGJLWO1yometVicNyPoAYI8++qhYSe6wKQSNUIHlHH7JcVf5nIWFBWzbZt++fcTicfK5HBOTk0xMTHD6zBk4fZp4IiGG4SXTg60cErwGk4dalRWtmpxJcCURbkDK2oNYMSua1rBxVXV3NbBj+bD7IFaa6zduEJIb9btt99zhDcNg586dvD4+zoXz59m3b5+IvL62tN+BilLOUNM04omEyK1lx68geVRSySS4gq2gJisrpmG07Px5XUmEw6+WE5qm6ZGNLufwzYAygImJCY4fP048Hmf/gQPvbVqneUN8F2xicpJYLCaGtjWNZCpFMpVi69at1P2At6kpbo6MYJom6c5O2js66M5kPPSj7TjUJXRbNeA0Wa0JSsVAv4VlI7AiIciahI0YhiFSHYmdsSwLNDHLfO3aNQ4///w9EUW4Lw4fCATYvGULw9evs3nzZuJ+3U8JzlKNCduyGpxdWTKRYG5uTjQ5dJ1IJCK4TqpVqpWKiDaWhaHrBGWUCZgmhut6XdBcLse6detWPN+gZOWq1+vLExQ1rUo3btzg9OnTdHV18fj+/QL4Jkml3o35N6wtj3GntWnXZWJ8nB7J+9JsgWDQ6+YWpBpfNptlfHyc8QsXOP/OOyRTKdKdnbS1t4tqGeK7DUklF3VUXW78/RYKhUSXtVajUi4LtXCZPrkgJrfkg3L12jVM0+SJp566s2tco90XhwdYPzTE5NgY58+f50DTJIuGyBVrEjcRjUaXbJBCMl/XNSHZrmYkoxLrUZEpj1KTq8jmVFDS7zmuuyYd0EAgAOWyB19oVUr1dw/feecdLl++zKZNm9i5c6fYiK0F2ruCrZq/t/iZChqtHHp+fp5isbgq9bguN5nxeJx2OcpYq1bJ5vPMzs4yPDLC1evXCZgmXV1d9PX2kunpWdN1hkIhb2in2CR6pqpApUqF0dFRdu/ataSid7fsnrMHm1J1QtM0Ht6+ndFbtxqYY0HkzCVJjxxqyseVua6QngyYJoVicUneF41GaUulSCQSAjIsKwDlSoVcPs/ExIQ4xio8iqqDq+m6B0hrZYqL/fLly+zevZs9e/YsOugqJcVVrUlZY6223OeNjo4SCoVIr8KupgBkxVKJubk5yuUyZjBIJpNh544dfPITn+CZp59m08aNlEolTp48yTe+/nVeeeUVLly82EiD3eLYkWgUxVpWKZe9CK9mGy5fuEA4HGbL1q2YpsnAwACapvH888+veu1vS8o+TdP4nd/5nWVfd+87rRIgVLYsMpkMvb29nPje93juuecEHoRF2RXTNJdNIxzbFg+DYQgtoIWFBoy9+iyVzrgqx5crRy6XE0POrsu8FMENBALelI3fFDS5Vqu1zCMrlQrHjh8nu7DAgYMHPREFVV7zN3Teja1Yg1eIwla/a9VscxxGb90SztMC56JG/izbxpaMAuVKRWxATVMEGd/YXzgcJt3Zyfbt26lUqx7Hz9WrVzl//rwAvMm6f6a7u6G6o2sa0UiEUqlErV4XQUvuC27euMHMzAxPPf20d88PHDjACy+8wKlTp1bte/ziL/4itm2zadMmfu7nfm7Z190XIqZQKES5WMSq1wXL1KuvcuToUZ5/7jk0Xffy3ZVIdxS+PJZIUKlUWMhmibeYllKmHrRQKIQTjTI2Niaw2L6h5Xq97ilbK/l39SCoFaKZ37BQKPDaa69hWRaHDh1a8tDBysMba7GVUhpXHLj1NbM03ZmZmaFSqTA4OOhxdionV5NGCiDnuq5HdxgKhUglkysOX4RDIdavW8f6detw5WdNjI8zJie9mgFvyWRSDJsEg1RrNe/+js/PMzw8zJ49e8j4NLYOHjzICy+8QDab5fLlyzz00EMtz+PFF1/kpZdeAuC3fuu3Vuyh3DeHB5G6RAIBnnzqKb7z8ssc/+532bNnj/eagMy1W5kjb048FhNfnFR97l4DUY/aSEUjEdpSKa+5ZNXrIn+0bapyugqEo1YrFWzJLhyLxTAMg/n5eY4fP45hmhx+5hliy6RHqwKefDX0lsMdK6Q0KzED+D/fkcjH4eFhsd8xTbK53BK4rkrhFM14Pp+nWquhy9VyraYBXek06XSa7Q8/TKlUEvyek5NcunyZd86fJxIOC27Pri6i0Si2bZPNZrlx4wZDQ0Ns2LhRrNI+h1d28uTJlg5fr9f55V/+ZQAOHTrEZz/72RXP8/5wSxoGgVAI17Kw63Wi0ShPHDzIa6+9xtvnzrH94YfFQ6EtnSEF8QXZloXmCnrmtrY2alNTggEhkVhT+apWqxGUU/Meh7zULFWjbGrqR/UIalL+0nFdpqamuHDhAm1tbezetcsDRmmakLJXJEzihBdx8ur8cReHOLzhjaZlWi3b/r2JBz2Wr/Mo/WRq4/3tp+Swba82PjY2Rm9fn8D6IyAUpml6g+sN2B7ZRAKWQAFWMj86Vb0jGo0uAt4ch5nZWSblAzB88ya6rhOJRqlUqyRSKfbs3o0uK3Yx2Rh87LHHxMihZXHixAl+/Md/fMln/97v/R6XL19G0zR+93d/d9VzvW+CCKFQiFK5TF2KEqc7O9m5cydnzpzBxfc0LwfEkv/WEBvbSCSCXSoxOz9P/2rCZ4i8O9YiZVKT9IFAAOTvVT7rui41y+LmjRvcuHGDTHc327dv93gjPUf05ezeg1KrEfCNFnolRl//QdXq6/W6N9mjpvht28bQdY/ISjmw7TieZLwXreX9seQAi4tIh+bn56nW6wwODhKLx8WDucJGWJFfwQq6rS1sSbdc3hO1Gum6LqDMmYyoxhSLXLlyheHRURxg+0MPNZxXm0SzRiIRdu/ezalTpzhx4sSSz52dneU//sf/CMBP/MRP8KhUkFnJ7qvDF3Qdyzeylclk2LV7NxfOn+e1V1/liSef9KK1n4fGP12krL29nbKEDK+loVStVGj3DT2sZIqeLhqLce3sWcbGxti2bRtbtm7FtizhGK7rbboc6YTK8epyCBqgsoKDlSoVHOngaqLL1TQh5OYI+RejCcxl+1YGXVuk9tM0jRDywTIMDE3j8qVLJONx0mvhZ3RdqpWKOM4dOHurAOUf5mim6wAxYnnj5k0iEtWpmmEuwsn9K/bBgwc5deoUp0+fXrKf+tVf/VUWFhaIxWL8xm/8Bmux++bwwWBQXDyiq6ZuRKari8yzz3L06FFeefllnnjySVLJpNcsauA2YXEjaJim4G7JZpmXF73S4Ea5UqFHRty1DBXU6nVOvfUWM1NTbNu2jW3bt6MhpR9b4HcUHMCxbc8Zg8Gg+PLk7/zRWKUXyAhoSjAVyJE7w/DQhxqAL2XSNa1lpFYrgDr/27dvs12edzP2Zsn11moePEAPBpcdoGl13c1HVSuP+r6VOY7DhQsXuHjxIj29vbSlUuh+TlAWo7uygwcP8l//63+lVCrxzjvveByb58+f5/d///cB+MIXvkDfGuVG75swsaZpRONxXMk3o5ozpqTweO655zBNk1dfeYWJyckGDVXwVR98X1pbKkXANLEdh/llpoeQx1ElxtUGjl2gUCzyyssvszA3x95HH6W3t3exJr/Mw6JyeFXlCQaDhEMhoVkaiRCJRgWQLhYjFosRj8W8nkA0GiUWjxOLxbwIp9I29W81lG4YxvJpie/aRoaHwXU9WnJNWxRFbhWRq9UqLqLs2MxktpK1upt+Pk+Nxfr+iRMnuHjhAlu2bmXz5s0EgkGMpkJFW1PVy79x9ac1v/RLv4RlWQwMDHib1rXYfXN4kJsRmZdWpOKeWsqj0SjPHj5MZzrNkTfe4M0336S+GmW2ptHW1kZAYbCXUX5TNBOqWrRk7hK81GRubo6XX36ZumVx+PBherq7Qebl6jNXO6eW/16j+Sed3m1Z03Vdrl+/Tm9/P8EWZUXl/Mrxq9Wqt1FXr19VjGCFc9OaHqjJqSle+ta3GBsbY99jjzEwMACuK5iiFUJTkrI2O/yWLVu8CbWTJ08C8I1vfINvfvObAPzGb/zGHYmy3VeHNwyDkGwp1yRNgz9amabJE088wZ5HHmF0dJSXXnpJqPX5cvhmJ4jKqGgYBlPT0y3HCSuVCmiax9UoDwQsOrrrukxOTPDaq68SiUR47vBhkrIOrYFXt77bM5bN5tXg73Su1mczMzPkCwU2rYI2VBUgxcIcDoU8QYoGcqcWtuJ9kPe2Wqtx4sQJ3njjDaLhMM8//7zn0LphoMumn5oOS/q4gvx24MABQER4y7L4pV/6JUBUcT7/+c+veI3Ndl8dHiCeTOJKVFyrKKJpGkMbNvCpT32KznSa7373uxw7dsybZW1lHZ2dBE0Tx3GYbdHeVg0Wb2MonVzR6wFcv36do8eOkenu5plnnvEeDl3XRbUFxBTPPTavJNkigq5VAuba9eskEwk61yDUplZaU4L8/FWlZU1bmXvTdV2GR0b4+7//e8bHx3l0716ePnRIkDupfYKk9Qj4WMzaW0ggwWJac+7cOf7zf/7PXLx4EYDf/d3fveNV8L47fCAQwJTlv7qsY/tzOAU5jUQiHDxwgCeeeIK5+XmOHDnCyOhoS+0nXddp7+jA1HUKxSIFn0KGOqa6LSqaqwqH67qcO3eO06dPs2njRg746O6UKWxOXWI+1mrvJiXxYAXNkW4Nn6shHHh8bIyhNWDJLcsSlOMI4iNNQnbVZ7W81lZVGZ/l8nneOHLE04/95Kc+xfqhIdHdlgEjHA7jys29Wg0MXadrGWFo5fC1Wo1/+2//LQCf+9znePrpp1e9xma7b1Uav0VTKXIzMx5Krrn54rf+vj4yXV2ceustLl+6xOjoKFu3bmXjhg0N1ZJIJEIikSCbzzMzO9vAPOY4jkcC6jdbNjRu3b7Nnj172OSbyPKb2izaUpRrVeWL95D2KE6dZSU7V/pYTfNYDFaDQbuIyhUSn+495DIQaMtw+7SqyoAYMLl48SK3b98mEAzy5BNPiFFD+Z6iZC0zTZNAMCh6EK7rfYddPT3LdnYPHDjgVdfqksf+t37rt1a8vuXs/XH4aBRME1cSn4aCwcWRvxZfaiAQYMeOHfT19XHr1i3OnTvHpYsX2bxlC5s3bfKaJG1tbZQrFarVKjOzs/T29HjpS/OD5QHAslkOHjy4alkrFAxSsm3BqLuKwyu8y7vZcnqTTu8ih3ddl+s3bjA4MLDqOVYrFRzLEsMbrfAyy5Q+m69pZnaWixcvMjkxQTwWY++jj9LX39+QklXKZS+VicViHkzYZZHnpre/f9lzVczMFy5cAODnf/7n3/U01Pvi8ACJdJr5W7col8vEYzGhROG6SxxTmS6HPnbt2sWOHTu4cvkyFy9c4NKlS2zZvJnNmzcTDIXoSqcZHx+nUi4zt7BAStJBK5AYiMmnI0ePYlsWzx46RKqtbdVUJRQMigEVSd6/kkO9l22tqqM3O/xa5CFvjY5SLpfZuMxK5R3LcbyKViQcXurY/rKigg34Ux1gemqKi5cuMT01RSKR4LHHH2egv1+AAeX0EgjGCdWEUzQdZZna6BKopoZKVrJMJsOFCxfo6uri3/27f7fqvVjO3jeHT6VSZCV3vKLM9jeWmk3VkB3bJhqLseeRR9i2bRtXrl7lypUrXL5yhb6+PgYHB0mmUszNzzM3N4fpqwLomsb0zAzHjx0jHA7zzOHDHhPuao0ZTdeJSHhEpVJZNYKqZtGdmr8s2fiL1QFjly9doru7m1QqteJrS+WywADJ9KLZ1L12ffsJV8IpRkdHGRkZIZfN0tbWxsGDB+np7W04X/Vv27JE2oSoAJmmKQbDq1VcbZHUqa+/f8X9zokTJ3j11VcB+LVf+7VVr28le98cPhAIEE0mKczOCqGrcplQJLKs4+nGUinGUDjMzp072bp1K8PDw4wMD3NsdBQzECCdTpNIJpmenvZq2mNjY5w5e5Z0ZycHDh70sNqarBqsVgUJhcOUZNNsRanHd5nD+z//TlOa8fFxcrkcT66ykavV69j1Oq6mLT/C6DOrXufW7duMjIwwNTmJZhj09/aya9cuupoo/vwpqXpAQAxs++V7qtWql7/Hk8lFkeVl7Atf+AIAO3fu5Kd/+qdXPeeV7H1zeE3TCMdiWKWSYAHWdUxf678V7wuyouPngAEBW9iyZQtbtmxhYWGB4Zs3GR4e5tbt26JjGQrhOA6nT59m3fr17N27d8kIoRfVVjhnXdcJSd70siRzXeUi7+ieeESiCiW5RnNdl4sXL5JOpxtoBFsdv1wqiaqMZPxd7nWzs7NckERStm3TlU7z2GOP0dvXt7KIsfxeyipvl6koiPtrScVBldN3ZzIrYu6/9KUv8corrwACGfleqffeN4cHUZ6qxGJU5udxbJtisUg8Hhc5ZVOUVHlmtVrlZ3/lV1hYWCDd1cVv//ZvezfBdV2SiQS7du1iy9at/Kf/9J+o1WpU63W2bN1KX08PhmEwOTFBuqtrCdfKSiSsDedcqXhQ4uWYDRxXwI7xAcwc1xUTUfJcC3KssVgooEtRgnKlghkIEJCMvMr59RUegqmpKRYWFnhqhejuIhghQOCQGpzMdcnnckxOTzM9Ocn0zAyVapV4LMa2hx5icHBwsZspYQLLRXYQzl6XBE7RSKRhj6D2DoZhkGpro03x4EsrlUqMjY2Rz+f52te+xq//+q8D8DM/8zM8++yzy17fWu19dfhIJEIhGCQYi1Erlwkibki4BYxX1wRW3jRN/tEP/RB//D//JzPT07z++uscPnwYwNucOq7LF7/4RW4ODxMMBPj0pz9NuVIRJERjY1y7ehVd02jv7BTgtUyGDik7qev6ki+04TxkI8qpVqlUKsRjMc+5LcvCtixyhYL3b1VBali1FJpQEYciJvcVFt+VCt91+T61BzF1XbB6KbFhmeZdunSJtrY2Muk0Nals2GwVWZVxNc1jZZ6emmJyepqpyUkqlQqarpPu6GD90BCpZJLunp6lD7QrpqIaeie+kUO/OEUkGl0iflaWCNGAaTK4fr0IcL57/Sd/8idL0pb9+/evCeu+FntfHV7TBDvWfK2GJimXy5WKGBgJBhuivKZpgnbOtjl8+DB/+41vMDs7y19/9as888wzi8Ao4I//+I85+eabAPzYj/0Ye/bs4cgbb5DJZOjKZIiEQkxPTzM5NcXVa9e4cOEChmnS2dlJm+RrSSaTJBOJlhWMcDhMuVymkM979WS/KaiwGrbQfRHaj4tXXIqRcFhAZEsldMT+JiS7kmpAxdEEk5prWWBZVOT15vNCFG3/gQPLplDFQoHJ6WmKhQLlcpnswgI5STvY1t7O4OAgGaU1axhks1mh67TSJl5rJGMFEdmrsiKjZmFdH/ND3bK80b5NW7YQiUSW4GBOnToFCDj50NAQP/qjP8q/+Tf/ZsXxzzux99XhQUZ5yYHulEo4liVSG133dH/UYIVpGFRl7veZz3yGL33pS8zOzvLyyy/z/HPPAfA3f/u3/N3f/z0A/8sP/iA/8P3fT75QEPgQx6GQz2MYBkNDQwwNDeG6LtlslsnpaeZnZ7l1+zaly5cFL6Wuk0wkaGtrI5VKEY/HCYZCuEClWhVR3HE8jSLTNxDuui7xWKwB9ttsnsaSnKc1dCEXGYlEvJRDpT9KZ1VxqluWheO6XL16VRAsRaPk83mKxSKlUolsLkduYYG5bFbQn0gYcjKVoqOzk23bttGVySxp9nilYVbpFDc95OVy2RsgiUYiXvVHCcaBYC/GdYknEvT29ZHw8xNJ++IXv8gXv/jFlZ3mPdj77vAgCFPn6nW0YBBdcssU8nmSyWRDtcI0TaEuZ9scOnSIr//N3zA+NsaLX/sah559lpMnTvBnf/qnADz5xBP803/6T4FFleqQpOLOLizgOg4d7e1oEnHZ1tYGW7YAYoAjm8uxsLBAdmGBufl5hkdHvbRDsSMEAgFC4TDJeJx4IkFEQoEdx1ncXLXYjyxnXg2+WZDAFVTSZcmbX65UKJfLzM7MMD83RzgS4Y0jR7yRRDUVlkwmGejrIxKNkkqlSKfTK1Z/miHZyzm8i9xYy3SrLImwFJWecnbdtwooPpq6ZfHwli3eg32/7QPh8OFwmFgsRlFODukycubzeUGrJ5seKme1LAs9EuGHf/iH+S//5b8wMzvLl//wD3nttddwXZeHd+zgZ376p70UR22KzECAVCpFLpslJ0V/O1qwDgQCAdKdnSSTSYrpNOtkbl0ulwXFhJR7UdH09sQEteFhMXfLYqVH0zRPTkfl3IZhCCZe2WkGeOv0aTQJqFNAN1sOYdfV2F1TChEIBERp1DC8SkcwGESTHD1mIOBtEAOmSWoZJKIyVXdfDpXqva4JBqIiO0huf5mz6/iGTlwx1ler1ejMZGhvbxcB5n2wD4TDAySTScFZaNu4UgfIsm2y+bzIpTVJ2u+63rzpwQMH+Ot16xgeGfFKV4Pr1vGvfuEXGkpnunxvXXLMawjsRy6Xw3Fd0k2lPCXRUpMD3EgsfUoqjqhI7DgOuWwWj+BJ0yiXy8zPzopqiyIMlSuD4zjYEmasZCAdmWqEw2GCoZDgbpHMa0pdT6VLYSnVEw6HGR4e5q3Tp3n62Wc95/EG0ut18oWC6HjKQKGUNlo5sqYtsjiryayWQybqoZN/l2W1CvAIbS3bXhwg0eRAuuuykM1ihkKsW79ezDDcyRjhXbQPjMNrmkZ7ezszti0ihqy4WJZFIZ8nlkigy+6gLSOhYZocfu45vvzlLwOie/t/fuELizqivuMHg0GveqAcd35hgWKhgOs4dEkobaVaFfKMiM1nSOqIevj5puZQWKqKlysVUokEoWQSU7bXo7EYIZ/yXrMtSMn6XTt3EovHKRYKGFLkDRYHtJvNsizOnz/PusHBpZFS7nd0wyAaDgu8itRFrdVqngCw93Iah7CXI4HSfM7uOA6lUsmbPYhIIlVVW1emKlO5XI5qrUb/4CB9fX3vSyqj7L7Dg1cywzDo6OjACIe9yABQk05vyx2/LtOaifFxXnjhBe/91WrVi+zNX1gwFGqgzksmk3R0dKDrOqVSianpaXL5PCXJUKzrOslkkliTgzRvQMOhkKjfu4IstMFWSQ8aXnoH9HqXLl+mblns2LFjye8UVR4IR0x3dAgHk46aV5Ul7xSXjvv5K17q/FXEVkLStsTLRKW6hx+eoUYlQUDAZ2ZniUSj9A8MvCdYwN2wD5TDg8ifO9JpMUisOneuS12K4YKIQnNzc/zmb/6m4HyXHc9KpcKLL764eDCfoylpTL8l4nE6pfz63Pw8E1NTWJZFJBwmmUg0dPWWrVrIFr2G7C76oBF3AjDw1C/8Dt8iupfKZa5cvcpWWdbzm2reAZ6UJ5pgEUvG455yucqnWx1f0RHqEoPkOTsioKgVUTcMj/lN13VPqcT/ANVrNSampnBdl56+PjZu3HgHd+Te2AfO4UHyF/b2LiEJsh2HarVKtVzmf/zBHzA+NUUoGORXfuVX2LdvHwDf+ta3mG+eetKE4rPKt/0WjUaFbpSE/hbL5Zbta+XsegsnCYZC3oa67J/M8jdnVrnm5gqNu8yqcPbsWQKGwdatWxt+7klDytUpJqO6Ml0qnwQDATTDoFIqtVS5duSmWUncqLJoSVaIQGz+FRubu3gCDddYqVZZWFigWi6Tam9n165d71ve7rcPpMODmMDp7OtrdD5ZBnvhq19lanKSeDTKz/38z7Nu3To++9nPepWOr/7VXy2+R37pqVTKq64sHs6lUChgyqZTMh4H12VsfJySTAv8piDGzUPKILqKIKZymkUBNFZQ8pDmZxtT19pst8fGGBsbY8+ePQ2bctd1RU4tcUaxaHTZTWc0GhX4d8OgUq0uYUhWD55ydluuGnV530KyotbMlOz4Nr3lUolyqUShUCCWTLJrz573PZVR9oF1eIBIPE5nT09D8+bFr32Nq1euEI1G+ZEf+RF27doFrsvAwAB7H30U13V55dVXmZqaajhWMplENwwvLQKB21AK0x0dHfT29hKSALap6WkWstmW59UK62NKfIqmaaKNfweIScVnA2KD2WqzWqvXOX36NL29vfQPDDS8t1QqiZTIcYQztsL3+B64cDjs7T0Uxh/wCKXUKlGtVJbk6+FQyGM+85CR8o/K72v1OqVikWA4zKYtWwRLwQfEPtAODxBOJmlLpwkFg3zn5Zc5+eabaLrO/v372frQQ8zPz3u55mc/+1kcV/Aj/vlf/EXDcRKSai6Xy4GmUfPJtiixXNM06e7uJibLgtmFBSanp1vO0bbK5yORiDcnq7qbnq3wAPhr38vRc5w5cwbHtnnkkUca3lcsFrFkmTYq04yW59r0+eFwmIDE5ZTKZaHe5y6SRBWLRW/A2zBN4vH44sPYdH6qKVYsFhtkLgfWrWPDhg2rSozeT/vAOzxAKJnk6PHjvPjii9i2zc4dO3h8/34sqfaWy+WoVqusGxzkgJScOX7sGMMjIw3NmkQiITAkiLEz13UJysEEZZqmkU6naW9vxzAMquUyExMTS/JdxS7WkN7IlEHTNKr1ekNqs1KlxpNbVxu/JsTmxOQko6Oj7Nq1q4GKsCjVr5EPbaCFY63EtBaNRLw0sSahEkpCyLZtgRuSBFL6Mg9ivV4nm81Sq9VE6qbr1Gs1egYG6Ovvv2dKHu/WPhQO/3d/93f8s3/xL5ibn2eDBBRFo1GCoRDlUolKpUJRahP943/8jz167L/88z/3cCiO45BMJsllswKTLYmHliPxSSQSdHV1YUpms/HJSbJy0+t3oOb0xpSsY7qmUZQPld9c3x///yN7DB4lnzTLsnjr1Cm6urpYLyUwHcehIJ1dQ4gTq2mixRMTUX2l0UVN9hE0TaNUKpHL54XjakIMIR6PL4rEaY1sZI5tUyqVKBSLAslpGII/tFiko6uLTHf3munv7qd9cNaaFewHf/AHRcnPsijOz4PjEJaMu47jCASeZREIBkkkEvy3//bfFum3wVMFbO/oYHhkhFw+j+M26oa2ioThcJju7m5mZ2epShGGQqlEW1uboO6QpjfBZSNS5cK2LIrlMhE1yQUeGA4WiWJty8KV5T2lIqJec/bcOSq1GockM65fwxYWnd1v/ibRaqZrGmW5l1HMDkoqFJYOxThSSE6xwrmuS1iC52ZmZ2nr6KCnt5dNmzZ9oFIZZR+KCK9MN01i7e3etHt3JiMGDDShD6o2Tdlcjlw+77W9Ncmm1dvTg+s4TE9P49i2R96kImGrWKjy+vaODgxdx67XmRwfF3sHf9fVlycrcJliBq750qFW1RPlaIZi2pWOOjIywvDNm+x95BFisdiis8sHONHs7GoTuVxUdxcprFVfo1gqedFbSdL4WQzUkVREz+fznrMbgQCxaJSgaTIzO0silfLq7R9EZ4cPSYT3m26aRDs7Kc3OeuIIeqEgNKCiUa/0WKtWKZfLRMJhotGomKGNxUimUkxPT4suq6yd+6sinqs0OXAikSASiTA/P0++UCCXy1Eulejo7BTEQipa2zaO3OgF5QpTLJdJSOBYK2dUIDLd5yTZbJa33nqLdevXM7R+PZYcdlcMvzH/BtXnyEsP7uLK/NtFsAhUqtWGjXhY0gnWLcvbyKr3WpKLx9+dNaUYNIiRvenZWWKJBL39/WzatOmOlEPut33oHB5kF7G9neLcnNBxkgLFoVCISCQiYLQyslarVQrFIuFwmHg8Tnd3N9euX2fbQw+tuJH0T/F4FNi6TmdnJ8FQiPn5eSzHYVIK/npQZm2R1jro46UsNY8vNn22gkyA2Ah+97vfJZFI8Mgjj3hK1pq8dlVnV3ghG4Ryig/YBSJlUp3bqtqMKggDQp81HAxiu0Iy0nEczEAAR+KZ6pKE1rvvgQBRWYlS4Lf5+Xki8Tj9g4Ns3LjxA+3s8CF1eBBRJpFOU8pmCddq1CyLaqVCIpWiLRQSIriVipefFgoFSsUi4VBIjOHl86Ta2kSOTyN2BBqrKpqv4wiCwDUUDDI3P0+pWCSby5HN5UjE4yQTiUXkoW0Tk5UhpRoSi8Ua2vXKdN/m982TJ6lWqzz55JMiX5YpUSAcFpUV8B4atXF1EQ6u/q1rGq5tU5L5tgcKQwDpQqGQN4VlSSaGmtwX+Xk8VboYlq9XD2o+n2chl6Oru5vOri6GhobuiXL23bYPrcODSAHinZ2YwaAnbV4sFDyt1lAoRDwWE1G+UKBarYoNlmkyPDxMLBYjLHNWXddbOr6yBp4ZiSVJp9PkQyGyuZynRJIvFAhHo2JUT1GBRyKiISMrIGG5oXbk/KotGz2O63LlyhVuj41x4MABQfYq51Aj4bAnroCsmmiAqevidSyKt1Wl5I7ti84aeJh5lQrZto1Vr3ugOT9MWKntBWTFST2glmUxMzuL4zgMrl9PV3c3AwMDH9icvdk+HGe5ioUTCboGB5kYHqZeq1EoFj2UoyGla6LRKNVajWKhQFsyyezcHLlcjkKh4OHR1cSSaRito778W5fsBnXLIiIx6qVSScyCys+oVirEYjGicsxPpVpVObMbVHLthiGURUyTsbEx3nnnHTZt2kQsHvfSqkQstiw7gtpwVuUD3wxrCCg92mAQzXU9Pam6ZXnOXZANo7B8qIIqmvvQjyDwMVMzM8TicTLd3fT399O1FjmdD5B9JBweIByN0rNhA2M3bwpmK9cloSbi5XIeCgYJdXSwbft2Xn/jDbLZLF3pNJasQJRKJU+uPhQKeaAwU04tKdNYxJyo1CcqGzTFYpHswgJlxyFfKOBOTBCPRkVjKBikXquJz5GYfRApyNzsLCdOnKC7u5vBdes8eZ1YLObhWuQHir6CbVO3bWw58liXM66AR31tSE1ay7KoFYstufPVpFMgECCTyTQCvOS11Wo1srkclXKZdHc3XZkM69atuyMhgg+KfWQcHkTdvG9oiPHRUWqlEsVSydNJgkXnVGK54+Pj7Nq9m7pUn1YTPJVKRdBWyG6qLmUeQ8EgpmTaVdQZzXzq8XhcAMk0jYKsHhWKRfLFonBCTUxfFQoFDz9fLBY5dekSbe3tbH/4YZH2qBQGkZvX6/VFJ29yXMWObCBWCge8TW6z6boueG+kdGcumxUsEYGAoBTx7V2Uo1fLZYxAgL716+np6WFgYOA9CTa8n6a591rS4n2wUqnE1NgYNVmdicjJH397fGR0lOPHj7N3716GZAfTdYVcfaVcFnmwFC1Wzg141RrP4XUh7KtGEBVMuJDPi36BaXoPkLKanEWtVqu8deYMhq6TiMfZtXMnwSaabyXcoPoFitBJ0xb1YU3TpCp1bP2mZmr9f/zVIMu2GZ+cpFar0dHe7uHna5UKuUKBiqzRBwIBNm/fzsDAwIcyqvvtIxXhlUWjUTq7u5mbnqaSy2FZFrFoFFdflFDMZDJ0dHRw5epVBgcGhKOyWMFQBEiKLbguS5+2bePIGVVVm/ZqGtIRdYlCRHYhdSlEVqlUBE2141Ct1z0hNl3XyXR3UyiVCPrxNwhcvMKoKKcNyQds8WNddMTDpYiaDPn6lXqt2VwOR866moEAC7kc1UpFVIVkBG/v6OCRxx77wGFi3q19JCO8slKpxOzMDNV8HiTrcCAQ8ABTwzdv8r2TJ9kuZSmNZeryCuuiISsbUrm7LKG1SgXbsSxRHpQzn5ZlEQqHqdfrTE1MMDk1xfTUFNl8HlPm53ogwHo5m6oIqILBICEpeWlIIqcv/9EfceToUR555BF+6V//a0+fVaEzLUVRvYav05X3ZnJ8nLyEPhi+yg+IeYQtDz3E0KZNaxpR/LDYRzLCK4tGowT7+pifn6eQzZLP572pf03TWD80xOTkJJcuX6atvZ2eTAbNMERq4PvyNfAcydB1DOmQanAZ4K9eeIG/+upX+e3f/m26urooyjG6cDjMv/qFX0DTddEkk/I5utwTDG3YwNDQELZtC0l4X3mvUq0SdBxM02TPnj0cPX6cc+fOia6yVMADqKuuaQtnVzSAdYnerNfrFMtl5ufmqNs2oUAAUx4nFAwSiUbp6Oxk49atRKUE/EfJPtIOD2KZT6fTBINBssEgtXyeWjZLUNak9+7dy0I2y9mzZwnv3y86prIerem6ABupjWnTsT3QmK+zqcucVwHGHMfxCKAAD504MzNDXaZOA/39HgBOmYLo1qWTrl+3jnUDA9Tqdb574oQAZ8ljKvy5Mn/1x5arjjp3hTdSnDbpzk4xBRUOEwgG6e7tpbuv7yMV1f32kXd4EJu3VCpFKBQiFw5TLhapSVhxMBjk0Ucf5Y033uDKlSts3bqVWDQqIq3rCj5HPxxYHk9N9vuJRdVmsFqtUioWycvxwU998pN09/RQrVTI5nL09/XxP/7gD0AeOyKhAp6iXiBAR3v7IhJURueNQ0MMDw8zdvs2WzZvFghHScHnWRNsQZ2vaRje5jcYDBKNRunr7xcbbsOgK5Mh09v7gZg7vZf2sXB4ZWGpaF1NJikUChRzOeqlEoFAgC1btnDp0iVc12XD0BDxeNxLfZpjnUJWKoVvNekfjUbJFQqCO0eNwQF79+7l/IUL2I7D448/3iC45kr+HaU1W5TRN5vNitp+JIImKyPbt2/n6NGjFIpFfuRzn6PuI3VqZZri50SwHRSLRUxdJxSP09HWRjgUojOToXsFzvePmn08rtJn/hp3MpkUgyPZLOulsNqlixcpFgps2LBBbB7D4UYeebkxtNX8p2rry/IgrqD0Dpsm1WqVK5cvMzMzQ39/P3v27CESiTAxMSHKmj5GMjV0kUgmBf5Hbnwr1aoYOTQMMbP73/87c3Nz3BwZYdOmTR4LWytzXJeq7C+oHkMoEiHd1UXfwAAd6XRLyZuPsn3sHN5vQbnxTKVS1Ot1uvr7SaXTHH/jDS5dusSGoSGBdNR1T6Oo2dSAuRreVnw2169f58rVq5imyeOPP+7JSCpuTBC5d/MMq6FpxONxgZAslXAch4VcTuwLwmE2btzItWvXeOvUKTZt3Li4v1AVGtmJVbV/S87umqZJb38/6zdsoPNDBge4m/axdnhluqqghEI8duAA6zZs4Ct/9me8efYsPek0/QMDAmUp89+grFsrmXbF416rVjn55ptUymVM02T94CCD69YRk9UONR6oHL7mw5h7JuG9wUAAI5HwJqfqtRr1apW9e/dye2yM06dP85nPfMZ72FzXxarXBT+nQj/WapjBIP3r1pHu7vY27x9ne+DwLSyTyfB//NzPcf78eY4ePcr3Tp2iI5kkIfN6hbuv1etirjOX4+KlS14JcO++fQwMDGBbllePV2jLqlTzVkhFVz4syrxZV9nEisViRMJhqrLx9fDDD3tkU9evX6etrU1AD1RTTFaNIrEYgxs30pFOC/74WOxDCwe4m/bA4ZcxXdfZuXMnO3bsYHR0lDNnzjA7M8PU1JRHNxcOBEglEiTicTKZDFeuXGH//v10Swl1Q9Moa5onxKurSgyIbqZs9vjN+z/fIIduGJ5IQjAQoLOjg1w+z/kLF3h03z5CoRDRZJJgKEQ0FiOeSHgU5IpF4YEJe+Dwq5imaaxbt65Byl1RUyjsTa1S4drICJacOZ2bnxd88KYpqLItC00qj9gyjWkmXnXBi/YueCVEW3LTW7IiEwgGGdq8mRdffJHjb77Jj//zfy7gBqGQ4IX34Xke2FJ74PDvwgJSBxYWS5NV2+bCtWvEOjpIpFKikuO6BF2XSjZLtlDAlXLrtVqNhMSm6LrO7NwcsEjEpEtueMM0CUqlbMVokGxr49lPfIL/9/d/n+sjI8Tj8fdNXODDaA8c/j2aGh4BmJmZoSuTYWBgwFPzsG2bQqHAwsICSjhhYWGBsxcuoOk6A5s20T80BMqppdM3oxwDgYDH1Hv48GHB8uW6nDx5kk9+8pPv7034ENkDh7/Lpklogb9j2dbWRr9PXv3GjRuMT06iaRq1Wo1e+bvlaPaa7Y033hCVnGCQAwcO3LNr+SjaA4e/T9Ys5Ovvjt6puvRf//VfA/Dcc895aiEPbG32oE71ITQl+vBDP/RD7/OZfPjsgcN/yOytt95iZGQEeODw78YeOPyHzFQ6s3fv3g8U7/qHxR7k8PfB3njjDa5ever9/8zMjPfvq1ev8od/+IcNr/+pn/qpZY/1ta99DYBPf/rTd/UcPy72wOHvg33pS1/ypDWb7ciRIxw5cqThZ8s5/OjoKG+99RbwIJ15t/bA4e+SHT58GOCeNoFUdB8cHGTv3r337HM+yvaRHuL+qNn3fd/38dJLL/GzP/uz/N7v/d77fTofSnuwaf2QWC6X45VXXgEepDPvxR44/IfE/vZv/5Z6vU4ymfTSpwd25/Ygh/+Q2He+8x1SqRSf/vSnP/ZDHO/FHuTwD+xjZQ9Smgf2sbIHDv/APlb2wOEf2MfKHjj8A/tY2QOHf2AfK3vg8A/sY2UPHP6BfazsgcM/sI+VPXD4B/axsgcO/8A+VvbA4R/Yx8r+f+rFxE0EhBx8AAAAAElFTkSuQmCC", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cudaq.show(blochSphereList[:2], nrows=2, ncols=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Can we show the entire list of 4 Bloch spheres we created? Absolutely!" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "execution": { + "iopub.execute_input": "2024-08-12T15:07:14.216536Z", + "iopub.status.busy": "2024-08-12T15:07:14.216265Z", + "iopub.status.idle": "2024-08-12T15:07:14.699615Z", + "shell.execute_reply": "2024-08-12T15:07:14.698970Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cudaq.show(blochSphereList[:], nrows=2, ncols=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What if we had to add multiple vectors to a single Bloch sphere? CUDA-Q uses the [QuTiP](https://www.qutip.org) toolbox to construct Bloch spheres. We can then add multiple states to the same Bloch sphere by passing the sphere object as an argument to `cudaq.add_to_bloch_sphere()`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2024-08-12T15:07:14.702524Z", + "iopub.status.busy": "2024-08-12T15:07:14.701986Z", + "iopub.status.idle": "2024-08-12T15:07:14.786974Z", + "shell.execute_reply": "2024-08-12T15:07:14.786389Z" + } + }, + "outputs": [], + "source": [ + "import qutip\n", + "\n", + "rng = np.random.default_rng(seed=47)\n", + "blochSphere = qutip.Bloch()\n", + "for _ in range(10):\n", + " angleList = rng.random(3) * 2 * np.pi\n", + " sph = cudaq.add_to_bloch_sphere(cudaq.get_state(kernel, angleList), blochSphere)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This created a single Bloch sphere with 10 random vectors. Let us see how it looks." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "execution": { + "iopub.execute_input": "2024-08-12T15:07:14.789597Z", + "iopub.status.busy": "2024-08-12T15:07:14.789332Z", + "iopub.status.idle": "2024-08-12T15:07:14.927975Z", + "shell.execute_reply": "2024-08-12T15:07:14.927184Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "blochSphere.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Unfortunately, there is no such handy visualization for multi-qubit states. In particular, a multi-qubit state cannot be visualized as multiple Bloch spheres due to the nature of entanglement that makes quantum computing so powerful. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Kernel Visualization\n", + "\n", + "A CUDA-Q kernel can be visualized using the `cudaq.draw` API which returns a string representing the drawing of the execution path, in the specified format. ASCII (default) and LaTeX formats are supported." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2024-08-12T15:07:14.930199Z", + "iopub.status.busy": "2024-08-12T15:07:14.929993Z", + "iopub.status.idle": "2024-08-12T15:07:14.943070Z", + "shell.execute_reply": "2024-08-12T15:07:14.942497Z" + } + }, + "outputs": [], + "source": [ + "@cudaq.kernel\n", + "def kernel_to_draw():\n", + " q = cudaq.qvector(4)\n", + " h(q)\n", + " x.ctrl(q[0], q[1])\n", + " y.ctrl([q[0], q[1]], q[2])\n", + " z(q[2])\n", + " \n", + " swap(q[0], q[1])\n", + " swap(q[0], q[3])\n", + " swap(q[1], q[2])\n", + "\n", + " r1(3.14159, q[0])\n", + " tdg(q[1])\n", + " s(q[2])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "execution": { + "iopub.execute_input": "2024-08-12T15:07:14.945150Z", + "iopub.status.busy": "2024-08-12T15:07:14.944920Z", + "iopub.status.idle": "2024-08-12T15:07:15.014021Z", + "shell.execute_reply": "2024-08-12T15:07:15.013438Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ╭───╮ ╭───────────╮ \n", + "q0 : ┤ h ├──●────●────╳───╳─┤ r1(3.142) ├───────\n", + " ├───┤╭─┴─╮ │ │ │ ╰───────────╯╭─────╮\n", + "q1 : ┤ h ├┤ x ├──●────╳───┼───────╳──────┤ tdg ├\n", + " ├───┤╰───╯╭─┴─╮╭───╮ │ │ ╰┬───┬╯\n", + "q2 : ┤ h ├─────┤ y ├┤ z ├─┼───────╳───────┤ s ├─\n", + " ├───┤ ╰───╯╰───╯ │ ╰───╯ \n", + "q3 : ┤ h ├────────────────╳─────────────────────\n", + " ╰───╯ \n", + "\n" + ] + } + ], + "source": [ + "print(cudaq.draw(kernel_to_draw))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "execution": { + "iopub.execute_input": "2024-08-12T15:07:15.016840Z", + "iopub.status.busy": "2024-08-12T15:07:15.016601Z", + "iopub.status.idle": "2024-08-12T15:07:15.020318Z", + "shell.execute_reply": "2024-08-12T15:07:15.019781Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\\documentclass{minimal}\n", + "\\usepackage{quantikz}\n", + "\\begin{document}\n", + "\\begin{quantikz}\n", + " \\lstick{$q_0$} & \\gate{H} & \\ctrl{1} & \\ctrl{2} & \\swap{1} & \\swap{3} & \\gate{R_1(3.142)} & \\qw & \\qw \\\\\n", + " \\lstick{$q_1$} & \\gate{H} & \\gate{X} & \\ctrl{1} & \\targX{} & \\qw & \\swap{1} & \\gate{T^\\dag} & \\qw \\\\\n", + " \\lstick{$q_2$} & \\gate{H} & \\qw & \\gate{Y} & \\gate{Z} & \\qw & \\targX{} & \\gate{S} & \\qw \\\\\n", + " \\lstick{$q_3$} & \\gate{H} & \\qw & \\qw & \\qw & \\targX{} & \\qw & \\qw & \\qw \\\\\n", + "\\end{quantikz}\n", + "\\end{document}\n", + "\n" + ] + } + ], + "source": [ + "print(cudaq.draw('latex', kernel_to_draw))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Copy this output string into any LaTeX editor and export it to PDF.\n", + "\n", + "\"Circuit" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "vscode": { + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/pr-2023/examples/python/tutorials/vqe.html b/pr-2023/examples/python/tutorials/vqe.html index 98da3d6ce4..c29d749edf 100644 --- a/pr-2023/examples/python/tutorials/vqe.html +++ b/pr-2023/examples/python/tutorials/vqe.html @@ -127,7 +127,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -320,8 +333,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -506,6 +525,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/examples/python/tutorials/vqe_water_active_space.html b/pr-2023/examples/python/tutorials/vqe_water_active_space.html index 69ec174672..2bb3b16eaf 100644 --- a/pr-2023/examples/python/tutorials/vqe_water_active_space.html +++ b/pr-2023/examples/python/tutorials/vqe_water_active_space.html @@ -32,7 +32,7 @@ - + @@ -127,7 +127,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -320,8 +333,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -506,6 +525,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • @@ -534,7 +554,7 @@
    @@ -746,7 +766,7 @@

    B- VQE-UCCSD: - +

    diff --git a/pr-2023/genindex.html b/pr-2023/genindex.html index 3abcd4d60f..4b5efbb88e 100644 --- a/pr-2023/genindex.html +++ b/pr-2023/genindex.html @@ -121,7 +121,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -314,8 +327,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -500,6 +519,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/index.html b/pr-2023/index.html index a27f5d0932..06fe789cdc 100644 --- a/pr-2023/index.html +++ b/pr-2023/index.html @@ -123,7 +123,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -316,8 +329,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -502,6 +521,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • @@ -562,6 +582,7 @@

    CUDA-Q Examples
  • Backends
  • Backends @@ -321,8 +334,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -507,6 +526,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/releases.html b/pr-2023/releases.html index 26d1dbcc64..513e4c2a42 100644 --- a/pr-2023/releases.html +++ b/pr-2023/releases.html @@ -122,7 +122,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -315,8 +328,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -501,6 +520,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • @@ -541,6 +561,33 @@

    CUDA-Q ReleasesDocumentation

  • Examples

    • +

    0.8.0

    +

    The 0.8.0 release adds a range of changes to improve the ease of use and performance with CUDA-Q. +The changes listed below highlight some of what we think will be the most useful features and changes +to know about. While the listed changes do not capture all of the great contributions, we would like +to extend many thanks for every contribution, in particular those from external contributors.

    + +

    The full change log can be found here.

    +

    0.7.1

    +

    The 0.7.1 release adds simulator optimizations with significant performance improvements and +extends their functionalities. The nvidia-mgpu backend now supports user customization of the +gate fusion level as controlled by the CUDAQ_MGPU_FUSE environment variable documented +here. +It furthermore adds a range of bug fixes and changes the Python wheel installation instructions.

    + +

    The full change log can be found here.

    0.7.0

    The 0.7.0 release adds support for using NVIDIA Quantum Cloud, giving you access to our most powerful GPU-accelerated simulators even if you don’t have an NVIDIA GPU. @@ -549,13 +596,13 @@

    CUDA-Q Releasesfollow our blog to learn more about the new setup and its performance benefits.

    -

    The full change log can be found here.

    +

    The full change log can be found here.

    0.6.0

    The 0.6.0 release contains improved support for various HPC scenarios. We have added a plugin infrastructure for connecting CUDA-Q diff --git a/pr-2023/search.html b/pr-2023/search.html index febef95719..1a88f37a21 100644 --- a/pr-2023/search.html +++ b/pr-2023/search.html @@ -124,7 +124,11 @@

  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/searchindex.js b/pr-2023/searchindex.js index c58c9bf9ed..364a757098 100644 --- a/pr-2023/searchindex.js +++ b/pr-2023/searchindex.js @@ -1 +1 @@ -Search.setIndex({"docnames": ["api/api", "api/default_ops", "api/languages/cpp_api", "api/languages/python_api", "examples/python/tutorials/cost_minimization", "examples/python/tutorials/deutschs_algorithm", "examples/python/tutorials/hadamard_test", "examples/python/tutorials/hybrid_qnns", "examples/python/tutorials/maximum_vertex_weight_clique", "examples/python/tutorials/noisy_simulations", "examples/python/tutorials/qaoa", "examples/python/tutorials/quantum_fourier_transform", "examples/python/tutorials/readout_error_mitigation", "examples/python/tutorials/vqe", "examples/python/tutorials/vqe_water_active_space", "index", "releases", "specification/cudaq", "specification/cudaq/algorithmic_primitives", "specification/cudaq/control_flow", "specification/cudaq/dynamic_kernels", "specification/cudaq/examples", "specification/cudaq/kernels", "specification/cudaq/machine_model", "specification/cudaq/namespace", "specification/cudaq/operations", "specification/cudaq/operators", "specification/cudaq/patterns", "specification/cudaq/platform", "specification/cudaq/synthesis", "specification/cudaq/types", "specification/index", "specification/quake-dialect", "using/backends/backends", "using/backends/hardware", "using/backends/nvqc", "using/backends/platform", "using/backends/simulators", "using/basics/basics", "using/basics/build_kernel", "using/basics/kernel_intro", "using/basics/run_kernel", "using/basics/troubleshooting", "using/examples/bernstein_vazirani", "using/examples/cuquantum", "using/examples/examples", "using/examples/expectation_values", "using/examples/hardware_providers", "using/examples/introduction", "using/examples/multi_control", "using/examples/multi_gpu_workflows", "using/examples/noisy_simulation", "using/examples/qaoa", "using/examples/quantum_operations", "using/examples/vqe", "using/extending/cudaq_ir", "using/extending/extending", "using/extending/mlir_pass", "using/extending/nvqir_simulator", "using/install/data_center_install", "using/install/install", "using/install/local_installation", "using/integration/cmake_app", "using/integration/cuda_gpu", "using/integration/integration", "using/quick_start", "using/tutorials", "versions"], "filenames": ["api/api.rst", "api/default_ops.rst", "api/languages/cpp_api.rst", "api/languages/python_api.rst", "examples/python/tutorials/cost_minimization.ipynb", "examples/python/tutorials/deutschs_algorithm.ipynb", "examples/python/tutorials/hadamard_test.ipynb", "examples/python/tutorials/hybrid_qnns.ipynb", "examples/python/tutorials/maximum_vertex_weight_clique.ipynb", "examples/python/tutorials/noisy_simulations.ipynb", "examples/python/tutorials/qaoa.ipynb", "examples/python/tutorials/quantum_fourier_transform.ipynb", "examples/python/tutorials/readout_error_mitigation.ipynb", "examples/python/tutorials/vqe.ipynb", "examples/python/tutorials/vqe_water_active_space.ipynb", "index.rst", "releases.rst", "specification/cudaq.rst", "specification/cudaq/algorithmic_primitives.rst", "specification/cudaq/control_flow.rst", "specification/cudaq/dynamic_kernels.rst", "specification/cudaq/examples.rst", "specification/cudaq/kernels.rst", "specification/cudaq/machine_model.rst", "specification/cudaq/namespace.rst", "specification/cudaq/operations.rst", "specification/cudaq/operators.rst", "specification/cudaq/patterns.rst", "specification/cudaq/platform.rst", "specification/cudaq/synthesis.rst", "specification/cudaq/types.rst", "specification/index.rst", "specification/quake-dialect.md", "using/backends/backends.rst", "using/backends/hardware.rst", "using/backends/nvqc.rst", "using/backends/platform.rst", "using/backends/simulators.rst", "using/basics/basics.rst", "using/basics/build_kernel.rst", "using/basics/kernel_intro.rst", "using/basics/run_kernel.rst", "using/basics/troubleshooting.rst", "using/examples/bernstein_vazirani.rst", "using/examples/cuquantum.rst", "using/examples/examples.rst", "using/examples/expectation_values.rst", "using/examples/hardware_providers.rst", "using/examples/introduction.rst", "using/examples/multi_control.rst", "using/examples/multi_gpu_workflows.rst", "using/examples/noisy_simulation.rst", "using/examples/qaoa.rst", "using/examples/quantum_operations.rst", "using/examples/vqe.rst", "using/extending/cudaq_ir.rst", "using/extending/extending.rst", "using/extending/mlir_pass.rst", "using/extending/nvqir_simulator.rst", "using/install/data_center_install.rst", "using/install/install.rst", "using/install/local_installation.rst", "using/integration/cmake_app.rst", "using/integration/cuda_gpu.rst", "using/integration/integration.rst", "using/quick_start.rst", "using/tutorials.rst", "versions.rst"], "titles": ["Code documentation", "Quantum Operations", "CUDA-Q C++ API", "CUDA-Q Python API", "Cost Minimization", "Deutsch\u2019s Algorithm", "Hadamard Test", "Hybrid Quantum Neural Networks", "Molecular docking via DC-QAOA", "Noisy Simulation", "Max-Cut with QAOA", "Quantum Fourier Transform", "Readout Error Mitigation", "Variational Quantum Eigensolver", "Water Molecule with Active Space (CPU vs. GPU)", "CUDA-Q", "CUDA-Q Releases", "Language Specification", "12. Quantum Algorithmic Primitives", "8. Control Flow", "9. Just-in-Time Kernel Creation", "13. Example Programs", "6. Quantum Kernels", "1. Machine Model", "2. Namespace and Standard", "5. Quantum Intrinsic Operations", "4. Quantum Operators", "10. Common Quantum Programming Patterns", "11. Quantum Platform", "7. Sub-circuit Synthesis", "3. Quantum Types", "Specifications", "Quake Dialect", "CUDA-Q Backends", "CUDA-Q Hardware Backends", "NVIDIA Quantum Cloud", "Multi-Processor Platforms", "CUDA-Q Simulation Backends", "CUDA-Q Basics", "Building your first CUDA-Q Program", "What is a CUDA-Q kernel?", "Running your first CUDA-Q Program", "Troubleshooting", "Bernstein-Vazirani", "Simulations with cuQuantum", "CUDA-Q by Example", "Computing Expectation Values", "Using Quantum Hardware Providers", "Introduction", "Multi-control Synthesis", "Multi-GPU Workflows", "Noisy Simulation", "Quantum Approximate Optimization Algorithm", "Quantum Computing 101", "Variational Quantum Eigensolver", "Working with the CUDA-Q IR", "Extending CUDA-Q", "Create your own CUDA-Q Compiler Pass", "Extending CUDA-Q with a new Simulator", "Installation from Source", "Installation Guide", "Local Installation", "CUDA-Q and CMake", "Using CUDA and CUDA-Q in a Project", "Integration with other Software Tools", "Quick Start", "CUDA-Q Tutorials", "CUDA-Q Versions"], "terms": {"c": [0, 1, 10, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 30, 35, 36, 37, 39, 41, 42, 43, 44, 45, 46, 47, 48, 49, 51, 52, 53, 54, 55, 61, 62, 63, 65, 67], "python": [0, 1, 2, 15, 16, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 29, 30, 35, 36, 37, 39, 41, 42, 43, 44, 45, 46, 47, 48, 49, 51, 52, 54, 58, 65, 66, 67], "quantum": [0, 3, 6, 9, 10, 12, 14, 15, 16, 17, 19, 20, 23, 29, 31, 32, 33, 34, 36, 37, 39, 40, 41, 44, 45, 46, 48, 50, 51, 55, 58, 59, 61, 62, 63, 65, 67], "oper": [0, 3, 5, 6, 7, 8, 9, 10, 11, 15, 17, 18, 20, 21, 22, 23, 27, 29, 30, 31, 32, 34, 35, 37, 39, 41, 44, 45, 46, 47, 48, 49, 51, 52, 53, 54, 55, 57, 58, 59, 61, 65], "cuda": [1, 4, 5, 7, 8, 9, 10, 11, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 35, 36, 42, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 64], "q": [1, 4, 5, 6, 7, 9, 10, 11, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 35, 36, 42, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 64], "provid": [1, 2, 3, 9, 11, 12, 13, 15, 17, 18, 20, 23, 25, 26, 28, 29, 30, 32, 34, 35, 36, 37, 40, 44, 45, 46, 48, 49, 51, 54, 55, 57, 58, 59, 61, 62], "default": [1, 2, 3, 8, 18, 22, 25, 30, 34, 35, 36, 41, 44, 47, 48, 54, 55, 58, 59, 61, 63, 65], "set": [1, 2, 3, 4, 5, 7, 10, 12, 15, 18, 20, 22, 25, 32, 35, 36, 37, 39, 41, 43, 44, 47, 51, 52, 54, 59, 61, 65], "These": [1, 2, 9, 10, 17, 22, 25, 29, 30, 32, 33, 35, 36, 37, 55, 59, 61], "can": [1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 18, 19, 20, 21, 22, 23, 25, 26, 27, 28, 29, 30, 32, 33, 34, 35, 36, 37, 39, 40, 41, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57, 58, 59, 61, 62, 63, 64, 65, 67], "us": [1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 14, 15, 16, 18, 19, 20, 21, 22, 25, 26, 28, 29, 32, 34, 35, 36, 37, 39, 40, 41, 43, 45, 46, 48, 50, 52, 53, 54, 55, 57, 58, 59, 62, 65, 67], "defin": [1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14, 17, 18, 19, 20, 21, 22, 26, 27, 28, 29, 30, 35, 36, 37, 39, 40, 41, 43, 44, 46, 47, 48, 49, 51, 52, 53, 54, 55, 58, 59, 61], "custom": [1, 2, 9, 18, 22, 36, 37, 48, 51, 54, 57, 59, 61, 64], "kernel": [1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 23, 25, 26, 27, 28, 29, 30, 31, 34, 35, 37, 38, 39, 41, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 63, 65, 67], "librari": [1, 2, 7, 8, 13, 16, 17, 22, 24, 29, 30, 37, 46, 55, 57, 58, 61, 63, 67], "sinc": [1, 2, 5, 10, 11, 12, 30, 33, 36, 37, 40, 46, 47, 50, 54, 55, 61, 62], "intrins": [1, 22, 29, 30, 32], "nativ": [1, 17, 23, 25, 26, 62], "support": [1, 2, 3, 12, 15, 16, 17, 22, 23, 25, 27, 30, 34, 40, 41, 44, 47, 48, 51, 52, 53, 54, 57, 63, 65, 67], "specif": [1, 2, 3, 15, 18, 22, 24, 25, 26, 27, 30, 32, 34, 35, 36, 37, 40, 41, 48, 53, 55, 58, 59, 61], "target": [1, 2, 3, 5, 6, 7, 9, 10, 14, 16, 18, 25, 28, 32, 34, 35, 36, 37, 41, 43, 44, 46, 47, 49, 51, 53, 55, 57, 58, 61, 65, 67], "depend": [1, 3, 5, 10, 18, 23, 32, 35, 36, 37, 43, 54, 65], "backend": [1, 2, 4, 15, 16, 18, 36, 41, 43, 44, 47, 50, 51, 55, 58, 59, 61, 65, 67], "architectur": [1, 2, 7, 15, 17, 23, 32, 34, 36, 47, 50, 53, 58, 59, 61, 65], "nvq": [1, 18, 21, 34, 35, 36, 37, 41, 44, 46, 47, 48, 49, 51, 54, 55, 58, 59, 61, 62, 63, 65], "compil": [1, 2, 3, 17, 18, 21, 22, 23, 27, 29, 30, 34, 35, 36, 37, 41, 44, 46, 47, 48, 49, 51, 54, 55, 58, 59, 61, 62, 63, 65], "automat": [1, 23, 34, 36, 37, 47, 54, 59, 61], "decompos": 1, "appropri": [1, 2, 5, 11, 17, 25, 36, 59, 61], "The": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 16, 17, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 41, 43, 44, 46, 47, 48, 50, 51, 52, 53, 54, 55, 57, 58, 59, 61, 63, 65, 67], "section": [1, 5, 11, 20, 36, 37, 59, 61, 65], "list": [1, 2, 3, 4, 5, 7, 8, 10, 11, 12, 13, 14, 18, 22, 33, 34, 35, 37, 43, 47, 50, 52, 53, 54, 59, 61, 65], "implement": [1, 2, 3, 5, 9, 10, 11, 17, 18, 23, 24, 25, 27, 29, 30, 32, 34, 37, 47, 48, 52, 55, 57, 58, 59, 61], "transform": [1, 5, 7, 14, 15, 17, 21, 55, 57], "state": [1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 13, 16, 18, 22, 23, 25, 30, 32, 35, 36, 39, 41, 43, 44, 46, 47, 48, 50, 51, 52, 54, 58, 59, 65, 67], "ar": [1, 2, 3, 5, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 19, 20, 22, 23, 25, 27, 29, 30, 31, 32, 34, 35, 36, 37, 40, 41, 45, 46, 47, 48, 50, 53, 54, 55, 58, 59, 61, 63, 65, 67], "templat": [1, 2, 13, 18, 20, 21, 22, 25, 29, 30, 47, 48, 55, 57, 58], "argument": [1, 2, 3, 5, 10, 12, 18, 20, 22, 29, 30, 34, 39, 41, 46, 49, 50, 54, 55, 58, 61], "allow": [1, 2, 3, 4, 5, 7, 16, 18, 20, 22, 23, 37, 39, 40, 41, 49, 50, 51, 53, 54, 55, 57, 61, 62, 63, 67], "invok": [1, 2, 3, 18, 20, 22, 27, 34, 37, 48, 55], "version": [1, 3, 7, 10, 11, 15, 16, 18, 27, 33, 34, 35, 36, 37, 41, 55, 58, 59, 61, 62, 63, 65], "see": [1, 2, 3, 4, 5, 11, 16, 18, 20, 22, 30, 32, 33, 34, 35, 36, 37, 39, 41, 43, 48, 50, 51, 52, 53, 55, 57, 59, 61, 62, 63, 65, 67], "addition": [1, 16, 61, 67], "overload": [1, 3, 18, 25, 26, 30, 32], "broadcast": [1, 2, 3, 10, 25], "singl": [1, 2, 3, 11, 13, 18, 21, 22, 23, 25, 30, 34, 35, 36, 41, 46, 47, 48, 50, 51, 53, 54, 55], "across": [1, 2, 3, 5, 16, 25, 35, 36, 37, 47, 61, 67], "vector": [1, 2, 3, 4, 7, 18, 20, 21, 22, 25, 28, 30, 32, 35, 36, 43, 44, 47, 48, 49, 50, 52, 54, 58, 59], "For": [1, 2, 3, 5, 10, 11, 12, 16, 18, 20, 25, 32, 34, 35, 36, 37, 39, 40, 41, 42, 43, 47, 49, 50, 52, 53, 54, 58, 59, 61, 63, 65, 67], "exampl": [1, 3, 4, 5, 7, 9, 10, 11, 15, 16, 17, 18, 20, 25, 31, 32, 34, 35, 36, 37, 39, 41, 43, 44, 46, 47, 48, 50, 51, 53, 54, 57, 58, 59, 61, 62, 63, 65, 67], "cudaq": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 19, 20, 21, 22, 24, 27, 28, 29, 34, 35, 36, 37, 39, 41, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57, 58, 59, 61, 62, 65], "qvector": [1, 2, 3, 6, 7, 8, 9, 10, 11, 12, 13, 14, 18, 21, 22, 25, 29, 35, 36, 39, 41, 43, 44, 46, 47, 49, 50, 52, 53, 54, 55, 65], "flip": [1, 2, 3, 4, 9, 12, 51, 53], "each": [1, 2, 3, 5, 6, 10, 11, 12, 16, 18, 20, 23, 28, 32, 34, 35, 36, 37, 41, 47, 50, 51, 52, 53, 54, 55, 59, 61, 65, 67], "thi": [1, 2, 3, 5, 8, 9, 10, 11, 12, 14, 17, 18, 20, 21, 22, 23, 24, 25, 27, 30, 32, 34, 35, 36, 37, 39, 41, 42, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57, 59, 61, 62, 63, 65], "pauli": [1, 2, 3, 6, 8, 10, 18, 26, 41, 53, 54], "matrix": [1, 2, 3, 9, 10, 16, 33, 35, 51, 53, 58, 67], "It": [1, 2, 5, 11, 12, 15, 18, 25, 30, 32, 36, 41, 51, 53, 55, 58, 61, 63, 65], "i": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 30, 32, 33, 34, 35, 36, 37, 38, 41, 42, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57, 58, 59, 61, 62, 63, 65, 67], "also": [1, 2, 3, 5, 9, 11, 12, 13, 16, 18, 22, 26, 34, 35, 36, 37, 39, 40, 41, 47, 50, 53, 54, 55, 57, 58, 59, 61, 63, 65, 67], "known": [1, 2, 22, 48, 55], "NOT": [1, 18, 25, 53], "gate": [1, 2, 4, 5, 7, 9, 10, 11, 12, 25, 29, 30, 32, 34, 37, 39, 43, 48, 49, 51, 54, 58], "appli": [1, 2, 3, 5, 7, 9, 10, 11, 12, 18, 21, 22, 25, 29, 32, 35, 36, 39, 43, 48, 49, 51, 53, 54, 55, 58], "0": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 21, 22, 25, 26, 27, 28, 30, 32, 33, 34, 35, 36, 37, 39, 41, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 58, 59, 61, 65, 67], "1": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 32, 34, 35, 36, 37, 39, 41, 42, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 58, 59, 61, 65, 67], "rotat": [1, 3, 9, 10, 11, 12, 25, 26, 39, 46, 51, 54, 58], "\u03c0": [1, 51], "about": [1, 2, 5, 12, 13, 16, 18, 32, 35, 36, 37, 40, 41, 47, 50, 51, 53, 59, 61, 63, 64, 65, 67], "axi": [1, 7, 13, 51], "enabl": [1, 2, 3, 11, 17, 18, 20, 22, 23, 25, 27, 28, 29, 30, 33, 36, 37, 40, 41, 46, 47, 50, 55, 58, 59, 61, 65], "one": [1, 2, 3, 4, 5, 10, 11, 16, 18, 20, 21, 23, 25, 28, 32, 34, 35, 36, 37, 42, 46, 47, 49, 50, 53, 54, 55, 57, 58, 59, 61, 65, 67], "creat": [1, 2, 3, 9, 10, 11, 12, 13, 15, 18, 20, 26, 29, 34, 35, 36, 40, 41, 47, 48, 50, 51, 52, 54, 55, 56, 58, 59, 61, 62, 65], "superposit": [1, 5, 10, 18, 21, 30, 36, 39, 41, 43, 51, 52, 53], "comput": [1, 2, 3, 5, 7, 9, 10, 11, 12, 13, 14, 15, 17, 18, 20, 21, 22, 28, 30, 32, 35, 36, 37, 40, 41, 45, 50, 52, 54, 58, 59, 63, 65], "basi": [1, 2, 3, 9, 11, 12, 14, 30, 35, 51, 53, 54], "sqrt": [1, 3, 5, 6, 9, 11, 12, 21, 51, 53, 65], "2": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 32, 34, 35, 36, 37, 41, 43, 46, 47, 49, 50, 51, 52, 53, 54, 55, 59, 61, 65, 67], "an": [1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 15, 16, 18, 20, 22, 23, 25, 26, 28, 29, 30, 32, 34, 35, 36, 37, 39, 41, 43, 44, 46, 47, 49, 50, 51, 53, 54, 55, 56, 57, 58, 59, 61, 63, 65, 66, 67], "arbitrari": [1, 2, 34, 49], "\u03bb": 1, "exp": [1, 2, 21, 26], "i\u03bb": 1, "math": [1, 5, 35], "pi": [1, 7, 8, 10, 11, 13, 21, 22, 27, 29, 34, 35, 47, 52], "std": [1, 2, 3, 18, 20, 21, 22, 25, 26, 28, 29, 30, 35, 36, 41, 43, 47, 48, 50, 52, 54, 57, 58, 63], "number": [1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 14, 18, 21, 26, 28, 30, 32, 34, 35, 36, 37, 39, 41, 43, 44, 46, 47, 48, 49, 50, 53, 54, 55, 58, 61, 65], "\u03b8": 1, "co": [1, 11], "isin": 1, "sin": [1, 11], "its": [1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 16, 17, 18, 28, 30, 32, 35, 36, 37, 41, 43, 48, 52, 53, 54, 55, 58, 59, 61, 65, 66, 67], "4": [1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 21, 22, 23, 25, 26, 27, 28, 29, 30, 34, 35, 36, 37, 47, 50, 52, 54, 55, 59, 61, 67], "i\u03c0": 1, "two": [1, 2, 3, 5, 6, 8, 9, 10, 12, 23, 32, 34, 36, 41, 46, 47, 49, 51, 53, 61, 63], "qubit_1": [1, 5, 10], "qubit_2": 1, "univers": [1, 35, 53], "three": [1, 12, 23, 34, 35, 46], "paramet": [1, 2, 3, 4, 7, 8, 10, 13, 14, 18, 22, 25, 30, 34, 35, 39, 44, 46, 47, 48, 50, 52, 54, 58, 59], "euler": 1, "angl": [1, 2, 3, 4, 6, 11, 12, 21, 22, 25, 36, 39, 46, 47, 54], "theta": [1, 6, 7, 8, 9, 10, 11, 13, 14, 18, 20, 21, 35, 36, 46, 52, 54], "phi": [1, 6, 18, 20, 55], "\u03c6": 1, "lambda": [1, 2, 8, 10, 12, 18, 21, 22, 27, 49, 50, 54, 55], "i\u03c6": 1, "np": [1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 21, 22, 27, 29, 34, 36, 37, 47, 50, 51, 52, 59], "m_pi": [1, 21, 29, 47, 52], "m_pi_2": [1, 21, 22, 35], "adj": [1, 25], "method": [1, 2, 3, 5, 7, 12, 13, 14, 18, 20, 25, 30, 36, 37, 41, 48], "ani": [1, 2, 3, 9, 10, 18, 22, 24, 25, 27, 29, 30, 34, 35, 37, 39, 41, 42, 47, 48, 49, 51, 58, 59, 61, 65], "alloc": [1, 2, 3, 4, 10, 18, 20, 21, 22, 23, 30, 36, 37, 39, 41, 43, 48, 49, 51, 54, 58], "now": [1, 5, 6, 10, 11, 13, 16, 32, 41, 47, 48, 49, 50, 51, 52, 53, 61, 65, 67], "again": [1, 18, 32, 51, 61, 63], "initi": [1, 2, 3, 4, 8, 10, 11, 13, 14, 18, 34, 36, 47, 50, 51, 52, 53, 54, 59, 61], "ctrl": [1, 2, 5, 10, 18, 20, 21, 25, 35, 36, 39, 43, 44, 46, 47, 48, 49, 52, 53, 54, 55, 61, 65], "condit": [1, 2, 9, 11, 18, 19, 20, 22, 23, 37, 40, 53, 55], "more": [1, 2, 3, 8, 10, 11, 12, 16, 20, 23, 25, 26, 32, 34, 35, 36, 37, 40, 41, 47, 50, 52, 53, 54, 59, 61, 63, 65, 67], "wikipedia": 1, "entri": [1, 18, 22, 36, 47, 55, 61], "ctrl_1": 1, "ctrl_2": 1, "00": [1, 9, 41, 50, 53, 65], "11": [1, 3, 9, 12, 18, 35, 41, 50, 53, 55, 59, 61, 63, 65], "onli": [1, 2, 3, 12, 18, 22, 23, 27, 30, 32, 34, 35, 36, 40, 43, 44, 47, 53, 55, 57, 59, 61, 65], "both": [1, 3, 5, 7, 23, 32, 34, 36, 37, 53, 54, 59, 61, 63], "000": [1, 11, 12, 35, 41], "111": [1, 11, 12], "follow": [1, 2, 3, 5, 6, 10, 11, 12, 16, 18, 20, 22, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 39, 41, 42, 46, 47, 48, 51, 55, 57, 58, 59, 61, 62, 65, 67], "common": [1, 12, 13, 18, 22, 25, 26, 55, 59, 63], "convent": [1, 7, 10], "all": [1, 2, 3, 6, 12, 15, 16, 17, 18, 19, 20, 22, 23, 24, 25, 27, 28, 30, 32, 34, 35, 36, 37, 41, 43, 46, 47, 50, 51, 52, 53, 54, 55, 59, 61, 62, 65, 67], "howev": [1, 11, 12, 32, 34, 36, 65], "behavior": [1, 2], "chang": [1, 2, 11, 16, 18, 22, 41, 61, 65, 67], "instead": [1, 2, 9, 24, 27, 37, 41, 59, 61], "when": [1, 2, 3, 10, 12, 18, 23, 30, 32, 35, 36, 37, 41, 46, 47, 48, 51, 55, 58, 59, 61, 65], "negat": [1, 2, 3, 25, 29, 30], "polar": [1, 25, 29, 37], "syntax": [1, 16, 17, 22, 23, 25, 27, 34, 47, 63, 67], "preced": [1, 25, 34], "01": [1, 5, 9, 53], "10": [1, 7, 8, 9, 10, 12, 14, 18, 21, 22, 41, 48, 50, 53, 54, 55, 65], "notat": [1, 53], "context": [1, 2, 7, 23, 36, 37, 58], "valid": [1, 2, 3, 15, 22, 34, 37, 47, 59, 61], "either": [1, 5, 7, 10, 23, 34, 36, 37, 47, 53, 54, 59, 61, 65], "similarli": [1, 5, 42, 53], "condition": 1, "respect": [1, 2, 3, 10, 18, 34, 36, 41, 46, 50, 59, 61, 65], "e": [1, 2, 3, 5, 6, 10, 11, 12, 13, 14, 17, 18, 19, 21, 22, 23, 24, 25, 26, 32, 34, 35, 36, 37, 44, 47, 55, 58, 59, 61, 65], "project": [1, 37, 58, 61, 62], "onto": [1, 53], "eigenvector": [1, 2, 6], "non": [1, 2, 3, 8, 12, 18, 22, 23, 30, 36, 37, 41, 46, 48], "linear": [1, 7, 9, 11, 13, 35, 41, 47, 53], "avail": [1, 2, 3, 8, 15, 16, 17, 18, 22, 23, 25, 28, 29, 30, 31, 33, 34, 35, 36, 37, 40, 41, 43, 45, 46, 55, 59, 61, 65, 67], "class": [2, 3, 7, 18, 20, 22, 26, 28, 30, 36, 37, 54, 57, 58], "spin_op": [2, 3, 18, 21, 25, 35, 36, 41, 46, 52, 54], "repres": [2, 3, 5, 9, 10, 11, 18, 32, 34, 37, 47, 53, 54, 55], "gener": [2, 3, 6, 8, 10, 11, 12, 13, 18, 20, 21, 22, 23, 25, 26, 29, 31, 34, 35, 40, 43, 44, 46, 47, 48, 49, 53, 55, 57, 61], "sum": [2, 3, 7, 10, 12, 26, 30, 47, 53], "tensor": [2, 3, 7, 12, 16, 26, 35, 44, 58, 67], "product": [2, 3, 12, 15, 16, 26, 35, 43, 65, 67], "expos": [2, 3, 18, 20, 26, 28, 32, 36, 58], "typic": [2, 18, 30, 35, 39, 40, 46, 55, 62, 63], "algebra": [2, 26, 46, 53], "programm": [2, 3, 18, 19, 20, 22, 23, 25, 27, 28, 30, 34, 36, 48], "primit": [2, 10, 17, 20, 23, 26, 30, 31, 36, 40], "them": [2, 6, 8, 12, 16, 32, 39, 53, 55, 59, 61, 63, 65, 67], "compos": [2, 3, 7, 10, 22, 23, 34, 47, 55], "larger": [2, 3, 10, 35, 43, 44], "complex": [2, 3, 8, 9, 14, 26, 32, 36, 41, 50, 51, 53, 54], "thereof": [2, 23, 26], "public": [2, 18, 20, 26, 28, 30, 36, 43, 54, 57, 58, 61], "type": [2, 4, 5, 10, 11, 12, 17, 18, 20, 22, 23, 25, 26, 31, 34, 36, 37, 39, 43, 46, 48, 51, 52, 53, 54, 55, 58, 61], "spin_op_term": 2, "bool": [2, 3, 18, 22, 25, 26, 28, 36, 58], "we": [2, 4, 5, 7, 8, 9, 10, 11, 12, 13, 16, 18, 21, 25, 27, 32, 34, 36, 37, 39, 40, 41, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57, 58, 59, 61, 62, 63, 65, 67], "term": [2, 3, 8, 10, 14, 18, 25, 34, 36, 41, 46, 61], "binari": [2, 3, 7, 10, 11, 16, 34, 43, 59, 67], "symplect": 2, "form": [2, 3, 16, 18, 25, 30, 32, 37, 55, 67], "size": [2, 3, 7, 12, 18, 20, 21, 22, 23, 30, 35, 36, 37, 43, 44, 47, 48, 50, 61], "nqubit": [2, 20, 21, 54, 58], "where": [2, 3, 5, 6, 7, 10, 11, 12, 17, 23, 25, 26, 30, 32, 34, 37, 41, 47, 50, 51, 53, 58, 59, 61], "first": [2, 3, 4, 5, 6, 9, 10, 11, 12, 13, 15, 18, 30, 34, 35, 36, 37, 38, 46, 47, 48, 49, 51, 54, 55, 61, 65], "n": [2, 6, 10, 11, 12, 14, 18, 20, 21, 22, 25, 26, 29, 35, 36, 41, 43, 44, 46, 47, 48, 49, 50, 52, 53, 54, 55, 59, 65], "element": [2, 3, 11, 12, 18, 30, 36, 53], "x": [2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 18, 20, 21, 22, 25, 26, 27, 29, 34, 35, 36, 37, 39, 41, 43, 44, 46, 47, 48, 49, 51, 52, 53, 54, 55, 59, 61, 65], "next": [2, 32, 47, 48, 54, 55, 59], "z": [2, 3, 4, 7, 8, 9, 10, 13, 18, 21, 25, 26, 35, 36, 41, 43, 46, 48, 50, 51, 52, 54, 59], "y": [2, 3, 5, 7, 11, 12, 14, 18, 21, 25, 26, 35, 36, 41, 46, 48, 51, 54, 59, 61, 65], "site": [2, 65], "csr_spmatrix": 2, "tupl": [2, 3, 18, 22, 54], "doubl": [2, 3, 13, 18, 20, 21, 22, 25, 26, 29, 35, 36, 37, 41, 46, 47, 52, 54, 58, 59, 61], "size_t": [2, 18, 20, 22, 26, 28, 30, 36, 47, 48, 58], "typedef": 2, "zero": [2, 3, 4, 6, 7, 12, 23, 36, 41, 53], "spars": [2, 3], "function": [2, 3, 4, 5, 7, 8, 9, 10, 12, 13, 14, 20, 21, 22, 24, 25, 26, 27, 28, 29, 30, 34, 35, 36, 37, 39, 40, 41, 43, 46, 47, 48, 50, 51, 52, 54, 55, 58], "pair": [2, 3, 10, 22, 28, 32, 61], "const": [2, 18, 20, 21, 22, 25, 26, 28, 30, 35, 44, 47, 52, 54, 57, 58], "termdata": 2, "constructor": [2, 3], "take": [2, 3, 5, 10, 11, 12, 16, 18, 20, 21, 22, 25, 26, 27, 28, 29, 30, 32, 34, 37, 40, 41, 44, 46, 47, 48, 49, 50, 51, 54, 55, 61, 65, 67], "coeffici": [2, 3, 8, 53], "constant": [2, 5, 30, 32, 55], "id": [2, 12, 18, 28, 30, 34, 36, 59, 61], "coeff": 2, "qubit": [2, 3, 4, 5, 7, 8, 9, 10, 11, 13, 14, 18, 20, 21, 22, 23, 26, 28, 29, 32, 34, 35, 36, 37, 39, 40, 41, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 58, 61, 65], "construct": [2, 12, 18, 19, 20, 22, 30, 32, 36, 39, 40, 41, 48, 51, 55], "represent": [2, 3, 11, 18, 22, 32, 37, 55, 57, 58], "unordered_map": [2, 18], "_term": 2, "full": [2, 3, 16, 35, 36, 50, 53, 55, 57, 59, 61, 62, 67], "composit": 2, "spin": [2, 3, 4, 6, 7, 8, 9, 10, 14, 18, 21, 26, 32, 35, 36, 41, 46, 50, 52, 54, 55], "op": [2, 3, 32, 46, 54, 55], "map": [2, 3, 9, 12, 18, 30, 55, 61], "individu": [2, 3, 23, 30], "bsf": 2, "from": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 16, 18, 19, 21, 22, 23, 26, 30, 32, 35, 36, 37, 40, 41, 43, 46, 47, 50, 51, 52, 54, 55, 58, 61, 62, 65, 67], "data": [2, 7, 8, 10, 11, 13, 15, 18, 22, 24, 26, 32, 36, 37, 44, 46, 48, 49, 55, 58, 60, 61], "ident": [2, 3, 10, 12, 32, 46], "numqubit": [2, 3, 21], "given": [2, 3, 5, 8, 10, 12, 18, 30, 34, 36, 37, 41, 43, 46, 54, 58], "o": [2, 6, 11, 14, 21, 34, 35, 36, 37, 44, 46, 47, 48, 49, 51, 54, 55, 59, 61, 63, 65], "copi": [2, 30, 32, 59, 61], "data_rep": 2, "serial": [2, 3], "encod": [2, 3, 10, 18, 26, 43, 48, 53, 58], "via": [2, 3, 5, 7, 9, 15, 17, 18, 20, 23, 25, 27, 29, 30, 32, 34, 36, 37, 44, 46, 47, 48, 49, 50, 51, 53, 55, 57, 58, 59], "3": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 19, 20, 21, 22, 23, 25, 26, 27, 28, 29, 30, 34, 35, 36, 37, 41, 47, 49, 50, 51, 52, 54, 55, 58, 59, 61, 62, 65, 67], "real": [2, 3, 6, 8, 11, 14, 40], "imaginari": [2, 3, 14], "part": [2, 3, 14, 18, 30, 55, 57, 59, 61], "append": [2, 3, 4, 6, 7, 8, 12, 13, 14, 22, 34, 36, 43, 50], "arrai": [2, 3, 5, 6, 9, 11, 12, 30, 32, 36, 48, 50, 51, 55], "larg": [2, 3, 12, 25, 37, 40, 44, 53], "1d": [2, 3, 53], "end": [2, 3, 5, 9, 11, 12, 18, 30, 34, 36, 41, 47, 51, 53, 59, 61], "total": [2, 3, 7, 8, 11, 14, 35, 36, 37, 41, 47, 50, 61], "destructor": 2, "iter": [2, 3, 18, 30, 47, 54], "begin": [2, 3, 5, 9, 11, 12, 13, 18, 30, 39, 47, 48, 51, 53, 54], "return": [2, 3, 4, 5, 7, 8, 10, 12, 13, 14, 18, 20, 21, 22, 25, 30, 32, 35, 36, 41, 43, 44, 46, 47, 48, 50, 51, 52, 54, 55, 57, 58, 59], "start": [2, 3, 4, 11, 15, 16, 25, 30, 34, 36, 41, 55, 57, 63, 67], "equal": [2, 3, 32, 36, 37, 41, 53], "v": [2, 3, 6, 8, 10, 15, 18, 21, 22, 27, 32, 35, 50, 55, 59], "noexcept": [2, 25], "add": [2, 3, 9, 10, 13, 16, 27, 37, 47, 48, 51, 55, 57, 58, 59, 61, 67], "subtract": [2, 3], "multipli": [2, 3], "true": [2, 3, 7, 12, 18, 22, 34, 50, 61, 65], "here": [2, 3, 5, 9, 11, 12, 13, 15, 16, 18, 20, 21, 22, 25, 27, 35, 36, 43, 44, 46, 48, 49, 51, 52, 54, 55, 57, 59, 61, 65, 67], "doe": [2, 3, 5, 11, 16, 18, 22, 30, 35, 36, 59, 61, 63, 65, 67], "consid": [2, 3, 5, 6, 12, 21, 23, 32, 35, 36, 55, 61], "valu": [2, 3, 4, 5, 7, 8, 10, 12, 14, 15, 18, 20, 22, 26, 30, 32, 35, 36, 37, 41, 43, 45, 50, 52, 53, 54, 55, 59, 65], "num_qubit": [2, 3, 26, 35, 54], "num_term": [2, 26], "get_coeffici": [2, 3, 8, 26], "get": [2, 3, 6, 9, 11, 12, 16, 18, 20, 21, 30, 34, 35, 36, 41, 46, 47, 50, 58, 59, 63, 65, 67], "throw": 2, "except": [2, 3], "get_raw_data": [2, 3], "is_ident": [2, 3, 26], "void": [2, 3, 18, 20, 21, 22, 25, 26, 28, 29, 30, 39, 41, 43, 47, 49, 52, 54, 55, 57, 58, 65], "dump": [2, 3, 9, 18, 21, 35, 36, 41, 43, 44, 47, 48, 50, 51, 52, 65], "string": [2, 3, 18, 20, 21, 28, 37, 41, 48, 55, 61], "standard": [2, 3, 17, 18, 19, 20, 22, 25, 31, 36, 39, 40, 44, 55, 57, 59, 61, 63], "out": [2, 3, 5, 7, 9, 10, 11, 16, 18, 23, 30, 32, 36, 37, 41, 42, 46, 47, 51, 53, 54, 58, 61, 62, 67], "to_str": [2, 3, 8, 41], "printcoeffici": 2, "getdatarepresent": 2, "getdatatupl": 2, "fulli": [2, 3, 7, 16, 17, 36, 48, 55, 59, 61, 67], "distribute_term": [2, 3], "numchunk": 2, "distribut": [2, 3, 9, 12, 16, 23, 35, 37, 41, 46, 48, 59, 67], "chunk": [2, 3, 23], "for_each_term": [2, 3, 8, 26], "give": [2, 6, 10, 11, 12, 16, 18, 36, 37, 51, 59, 61, 66, 67], "functor": 2, "reduct": 2, "captur": [2, 10, 22], "variabl": [2, 10, 22, 23, 34, 35, 36, 42, 44, 47, 50, 51, 59, 61, 65], "for_each_pauli": [2, 3, 26], "thrown": [2, 3], "than": [2, 3, 10, 11, 25, 32, 35, 37, 41, 53, 59, 61], "user": [2, 3, 12, 18, 20, 21, 23, 24, 27, 30, 34, 35, 36, 37, 47, 50, 51, 55, 58, 59, 61], "should": [2, 3, 11, 17, 18, 23, 25, 26, 28, 30, 34, 36, 37, 41, 43, 51, 58, 59, 61, 63, 65], "pass": [2, 3, 7, 8, 15, 18, 22, 23, 26, 30, 34, 36, 44, 47, 49, 51, 54, 55, 56, 61], "index": [2, 3, 26, 28, 30, 32, 36, 43, 58], "complex_matrix": 2, "to_matrix": [2, 3, 6], "dens": 2, "to_sparse_matrix": [2, 3], "row": [2, 3], "col": 2, "static": [2, 3, 18, 25, 30, 55, 59], "random": [2, 3, 8, 10, 12, 13, 14, 36, 37, 43, 50, 52, 54], "nterm": 2, "unsign": 2, "int": [2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 14, 18, 21, 22, 29, 30, 35, 36, 39, 41, 43, 44, 46, 47, 48, 49, 50, 51, 52, 54, 55, 58, 59, 65], "seed": [2, 3, 8, 10, 12, 13, 14, 37, 50, 52], "random_devic": 2, "act": [2, 4, 5, 10, 32, 53], "specifi": [2, 3, 7, 8, 10, 11, 12, 18, 21, 22, 23, 25, 26, 27, 28, 30, 34, 35, 36, 37, 41, 43, 47, 48, 50, 51, 52, 55, 58, 59, 61], "overrid": [2, 18, 37, 57, 59], "repeat": [2, 12, 18, 52, 54], "from_word": [2, 3], "pauliword": 2, "input": [2, 3, 5, 7, 8, 11, 18, 20, 21, 22, 29, 30, 36, 41, 46, 47, 50, 54], "word": [2, 3, 8, 51], "g": [2, 3, 10, 17, 18, 19, 22, 23, 24, 25, 26, 32, 34, 35, 36, 37, 47, 55, 58, 59, 61, 62, 65], "xyx": [2, 3], "3rd": 2, "second": [2, 3, 5, 10, 12, 30, 35, 37, 41, 54], "typenam": [2, 18, 20, 21, 22, 25, 29, 30, 47], "qualifiedspinop": 2, "struct": [2, 18, 20, 21, 22, 25, 29, 35, 44, 46, 47, 48, 49, 52, 54, 55, 57], "constexpr": [2, 20, 30, 35], "dyn": [2, 30, 44, 51], "level": [2, 17, 18, 23, 25, 35, 36, 37, 55, 58, 62], "qudit": [2, 19, 23, 25], "d": [2, 3, 21, 22, 23, 30, 34, 47, 51, 54, 61], "system": [2, 3, 13, 18, 23, 28, 30, 32, 36, 37, 40, 41, 46, 47, 50, 51, 53, 54, 57, 59, 62, 63, 65], "inlin": [2, 18, 55], "new": [2, 3, 11, 15, 16, 18, 20, 32, 40, 55, 56, 59, 61, 65, 67], "uniqu": [2, 3, 10, 12, 18, 23, 25, 30, 36, 63], "enable_if_t": 2, "qreg": [2, 3, 10, 35], "A": [2, 3, 5, 10, 12, 13, 18, 21, 22, 25, 32, 34, 41, 47, 49, 50, 53, 57, 58, 59, 61], "contain": [2, 3, 10, 12, 15, 16, 18, 23, 25, 28, 32, 35, 37, 40, 41, 46, 47, 52, 54, 55, 58, 59, 65, 67], "dynam": [2, 3, 20, 22, 23, 30, 39, 40, 44, 55], "time": [2, 3, 9, 10, 11, 12, 14, 17, 18, 21, 23, 30, 31, 34, 35, 37, 41, 44, 47, 48, 50, 53, 55, 59, 61, 65], "By": [2, 18, 25, 34, 35, 36, 37, 41, 47], "regist": [2, 3, 11, 13, 18, 21, 23, 30, 34, 36, 43, 48, 49, 51, 55, 58], "like": [2, 3, 5, 10, 11, 13, 18, 22, 30, 34, 36, 41, 47, 48, 50, 53, 54, 55, 59, 61, 62, 65], "value_typ": 2, "indic": [2, 3, 22, 25, 26, 30, 51, 58], "underli": [2, 3, 18, 28, 30, 34, 36, 58], "auto": [2, 18, 20, 21, 22, 26, 29, 30, 35, 36, 37, 39, 41, 43, 44, 46, 47, 48, 49, 51, 52, 54, 55, 57, 65], "interfac": [2, 30, 37, 58, 59, 61], "idx": [2, 3, 7, 30, 36], "qspan": 2, "front": [2, 21, 29, 30, 49], "count": [2, 3, 6, 8, 10, 12, 18, 20, 21, 30, 34, 35, 36, 37, 41, 44, 47, 48, 49, 50, 51, 52, 54, 55, 58], "back": [2, 21, 30, 32, 47, 48, 51, 61], "last": [2, 12, 21, 30, 36, 46, 54], "slice": [2, 3, 30, 54], "clear": [2, 3, 18, 30, 58], "destroi": [2, 30], "postcondit": [2, 30], "own": [2, 3, 9, 12, 23, 28, 30, 37, 54, 55, 58, 59, 61], "semant": [2, 3, 17, 22, 23, 24, 27, 29, 30, 32, 55], "held": 2, "explicit": [2, 18, 29, 37, 47], "determin": [2, 5, 41, 63], "If": [2, 3, 5, 7, 8, 11, 12, 18, 32, 35, 37, 41, 43, 47, 50, 53, 54, 59, 61, 65], "check": [2, 16, 34, 35, 47, 53, 59, 61, 67], "norm": [2, 12], "pre": [2, 14, 16, 18, 34, 37, 46, 47, 49, 59, 67], "exist": [2, 3, 16, 17, 18, 23, 24, 41, 53, 57, 59, 61, 65, 67], "could": [2, 35, 39, 53, 54, 59], "from_data": [2, 3], "retriev": [2, 3, 18, 47], "get_stat": [2, 3, 6, 11], "delet": [2, 30, 61], "cannot": [2, 11, 21, 22, 30, 32, 53, 61], "move": [2, 7, 30, 57, 59, 61, 65], "assign": [2, 10, 28, 36, 37, 59], "qview": [2, 6, 11, 21, 22, 29, 43], "observe_result": [2, 3, 18, 46], "encapsul": [2, 7, 18, 30, 36], "observ": [2, 3, 4, 6, 7, 8, 9, 10, 12, 13, 14, 21, 34, 36, 37, 38, 40, 44, 46, 48, 49, 50, 52, 53, 54, 58, 65], "call": [2, 3, 4, 5, 7, 9, 10, 11, 13, 20, 21, 22, 25, 29, 37, 40, 41, 47, 48, 49, 50, 52, 53, 54, 55, 58, 61], "includ": [2, 3, 10, 16, 18, 21, 30, 35, 39, 40, 41, 43, 44, 46, 47, 48, 49, 51, 52, 54, 55, 57, 58, 59, 61, 65, 67], "measur": [2, 3, 5, 6, 7, 9, 11, 12, 18, 19, 21, 22, 23, 25, 32, 34, 36, 37, 39, 40, 41, 43, 47, 48, 51, 54, 55, 58, 65], "execut": [2, 11, 16, 17, 18, 20, 22, 23, 28, 29, 34, 36, 37, 40, 41, 42, 43, 44, 46, 47, 48, 50, 55, 58, 61, 62, 63, 65, 67], "ansatz": [2, 4, 10, 13, 14, 18, 21, 35, 36, 46, 52, 54], "circuit": [2, 3, 5, 6, 7, 10, 11, 12, 17, 18, 22, 23, 26, 27, 31, 32, 34, 35, 36, 37, 40, 41, 46, 47, 52, 54, 55, 57], "global": [2, 3, 10, 18, 22, 35, 41], "expect": [2, 3, 4, 7, 8, 9, 10, 12, 13, 14, 15, 18, 35, 36, 37, 41, 45, 50, 51, 52, 54, 59, 61, 65], "h": [2, 3, 5, 6, 8, 10, 11, 12, 13, 14, 18, 20, 21, 25, 26, 27, 29, 30, 32, 34, 35, 36, 39, 41, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57, 58, 59, 61, 65], "precomput": 2, "psi": [2, 4, 5, 6, 18, 21, 41, 53], "sample_result": [2, 3, 18, 47], "wa": [2, 3, 5, 18, 36, 48, 55, 59, 62, 65], "shot": [2, 3, 6, 8, 12, 18, 21, 34, 41, 48, 53, 58], "base": [2, 3, 7, 11, 12, 16, 17, 18, 20, 24, 25, 30, 35, 36, 37, 41, 43, 50, 54, 55, 58, 59, 61, 63, 67], "raw_data": [2, 18], "raw": [2, 3], "convers": [2, 18], "simpli": [2, 53, 61, 65], "ignor": [2, 37], "fine": [2, 18, 44, 48, 49, 53], "grain": [2, 18, 44, 48, 49], "explicitli": [2, 32, 34, 37, 55, 63], "request": [2, 18, 35, 36, 37, 47, 61], "oppos": 2, "observe_data": 2, "spinoptyp": [2, 18], "sub": [2, 3, 17, 18, 21, 22, 30, 31, 61], "id_coeffici": [2, 18], "executioncontext": 2, "abstract": [2, 17, 18, 20, 25, 26, 28, 30, 36, 40], "how": [2, 4, 10, 11, 12, 13, 16, 18, 20, 25, 35, 36, 37, 40, 41, 45, 47, 48, 49, 50, 51, 52, 53, 54, 55, 58, 59, 61, 62, 65, 67], "name": [2, 3, 10, 18, 20, 25, 28, 33, 35, 37, 46, 50, 53, 55, 58, 59, 61, 62, 65], "shots_": 2, "member": [2, 3, 10, 22, 54], "basic": [2, 4, 15, 35, 61, 65], "sampl": [2, 3, 5, 8, 9, 10, 12, 20, 34, 35, 36, 37, 38, 40, 43, 44, 47, 48, 49, 50, 51, 52, 53, 58, 61, 65], "option": [2, 3, 5, 12, 13, 14, 18, 20, 25, 28, 34, 35, 36, 41, 46, 47, 49, 50, 54, 58, 59, 61, 63], "result": [2, 3, 4, 5, 7, 8, 9, 11, 12, 13, 14, 18, 19, 20, 21, 23, 32, 34, 35, 36, 37, 41, 43, 44, 46, 47, 48, 49, 50, 51, 53, 55, 58, 61, 65], "invoc": [2, 3, 20, 22, 28, 30, 36, 37, 58], "expectationvalu": 2, "nullopt": 2, "optimization_result": [2, 18], "optresult": 2, "optim": [2, 4, 7, 8, 10, 12, 14, 15, 17, 27, 30, 32, 35, 37, 45, 54, 55, 57, 59, 61], "hasconditionalsonmeasureresult": 2, "fals": [2, 3, 8, 59, 61], "being": [2, 3, 4, 9, 17, 18, 32, 37, 47, 51], "ha": [2, 3, 5, 9, 10, 12, 18, 25, 32, 34, 35, 37, 40, 41, 43, 47, 50, 51, 53, 54, 59, 61], "statement": [2, 5, 18, 19, 40], "noise_model": [2, 3, 9, 12, 51], "noisemodel": [2, 3, 9, 12, 51], "nullptr": 2, "current": [2, 3, 16, 18, 28, 34, 36, 37, 43, 58, 61, 67], "canhandleobserv": 2, "flag": [2, 22, 34, 36, 37, 44, 47, 55, 57, 61], "handl": [2, 3, 34, 35, 36, 37, 43, 44, 47, 58, 61], "task": [2, 18, 26, 36, 37, 41, 55, 58], "under": [2, 12, 34, 57, 58, 59, 61], "asyncexec": 2, "occur": [2, 3, 12, 18, 23, 47, 51, 53, 61], "asynchron": [2, 3, 18, 28, 36, 41, 47, 50], "detail": [2, 10, 16, 17, 23, 34, 35, 58, 59, 61, 65, 67], "futur": [2, 3, 18, 33, 34, 36, 37, 47, 51, 59, 61], "futureresult": 2, "store": [2, 3, 23, 30, 36, 41, 47, 50, 53, 55], "unique_ptr": 2, "simulationst": 2, "pointer": [2, 3], "simul": [2, 4, 8, 12, 15, 16, 17, 18, 33, 34, 36, 38, 40, 41, 43, 45, 47, 48, 50, 55, 56, 59, 65, 67], "amplitudemap": 2, "amplitud": [2, 3, 11, 50, 51, 53], "overlapcomputest": 2, "overlap": [2, 3], "overlapresult": 2, "trace": [2, 3, 9, 35], "kerneltrac": 2, "run": [2, 3, 5, 7, 12, 14, 15, 17, 18, 21, 34, 35, 36, 37, 38, 40, 44, 46, 47, 48, 49, 50, 51, 54, 55, 58, 59, 61, 62, 65], "tracer": 2, "persist": [2, 18, 23, 35, 61], "resourc": [2, 28, 35, 36, 37, 41, 54, 59, 61], "kernelnam": [2, 3], "batchiter": 2, "batch": [2, 23], "observe_n": 2, "sample_n": 2, "totaliter": 2, "registernam": [2, 18], "mid": [2, 3, 37], "mode": [2, 3, 23, 34, 47, 55, 59], "keep": [2, 12, 18, 37, 54], "track": [2, 18, 53, 54], "reorderidx": 2, "inform": [2, 3, 5, 16, 18, 23, 25, 28, 30, 34, 35, 36, 37, 41, 47, 50, 53, 55, 59, 61, 63, 64, 65, 67], "reorder": 2, "after": [2, 3, 5, 18, 41, 47, 51, 55, 59, 61], "empti": [2, 3, 20, 26, 37, 47, 51, 61], "mean": [2, 11, 25, 32, 37, 47, 50, 61, 65], "char": [2, 21, 36, 41, 59, 65], "invocationresultbuff": 2, "buffer": [2, 36], "note": [2, 3, 10, 12, 21, 23, 32, 35, 36, 41, 43, 47, 51, 53, 54, 55, 59, 61, 63], "need": [2, 9, 10, 11, 12, 32, 34, 35, 36, 37, 41, 46, 47, 50, 53, 54, 58, 59, 61, 62], "abl": [2, 18, 34, 35, 36, 41, 43, 53, 61, 65], "job": [2, 10, 18, 35, 36, 47, 61], "identifi": [2, 10, 43, 59, 61], "qpu": [2, 3, 6, 15, 16, 17, 18, 23, 28, 34, 36, 37, 40, 41, 46, 47, 50, 58, 65, 67], "extra": [2, 25, 32, 34, 43, 51, 54], "configur": [2, 13, 28, 34, 35, 36, 37, 47, 50, 55, 58, 59, 61, 62, 65], "later": [2, 5, 18, 22, 36, 47, 59, 61], "server": [2, 34, 36, 47, 61], "file": [2, 18, 25, 34, 35, 36, 41, 42, 47, 50, 54, 55, 57, 58, 59, 61, 62, 63, 65], "read": [2, 3, 10, 47, 54], "wrap": [2, 18, 20, 32], "t": [2, 3, 5, 6, 11, 16, 18, 21, 22, 25, 26, 35, 37, 47, 48, 53, 59, 61, 67], "case": [2, 3, 5, 9, 10, 11, 12, 18, 32, 39, 46, 51, 59, 61, 63], "must": [2, 3, 12, 17, 18, 22, 24, 27, 30, 32, 34, 37, 47, 51, 53, 54, 57, 58, 59, 61, 65], "some": [2, 7, 11, 18, 32, 35, 36, 37, 53, 55, 57, 58, 59, 61, 62, 65], "point": [2, 3, 11, 18, 22, 25, 36, 37, 55, 58, 59, 61], "within": [2, 3, 13, 18, 22, 24, 26, 30, 34, 36, 37, 40, 41, 47, 48, 51, 53, 57, 59, 61, 62, 65], "same": [2, 3, 5, 10, 11, 12, 18, 32, 34, 36, 41, 47, 49, 50, 51, 55, 58, 59, 61], "runtim": [2, 8, 17, 18, 20, 23, 34, 35, 36, 37, 44, 46, 55, 58, 61, 63], "_job": 2, "qpunamein": 2, "config": [2, 58, 59, 61, 65], "info": [2, 35, 42, 55], "requir": [2, 3, 5, 7, 11, 18, 22, 24, 25, 27, 29, 30, 32, 34, 35, 36, 37, 43, 47, 50, 53, 59, 62, 65], "date": 2, "even": [2, 5, 10, 16, 37, 54, 59, 61, 67], "async_result": [2, 47], "face": [2, 24], "which": [2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 16, 18, 20, 23, 26, 30, 32, 34, 36, 37, 46, 47, 48, 50, 53, 54, 55, 58, 59, 61, 62, 67], "itself": [2, 29, 32, 36, 59, 61], "collect": [2, 3, 8, 41], "pertin": [2, 18, 24, 29, 30], "remot": [2, 3, 18, 23, 33, 35, 42, 50], "rest": [2, 3, 17, 34, 36, 43, 47, 59, 61], "wait": [2, 3, 35, 36, 41, 47], "until": [2, 3, 41, 47], "readi": [2, 13, 47, 51, 61], "executionresult": 2, "bit": [2, 5, 9, 12, 18, 21, 23, 30, 32, 36, 37, 43, 44, 48, 49, 51, 53, 58, 63], "correspond": [2, 3, 4, 10, 18, 34, 43, 47, 48, 52, 59, 61], "well": [2, 3, 12, 16, 18, 21, 23, 37, 43, 58, 59, 61, 62, 67], "integ": [2, 3, 10, 22, 28, 36, 37, 41, 50], "1st": [2, 9], "bitstr": [2, 3, 10, 18, 43], "m": [2, 6, 12, 14, 21, 26, 36, 37, 50, 55, 59, 61, 65], "tripl": [2, 55], "long": [2, 18, 21, 41, 44, 59, 61, 65], "length": [2, 12, 43, 47, 54], "deseri": 2, "discuss": [2, 57], "brief": [2, 51, 58], "countsdictionari": [2, 18], "assum": [2, 3, 10, 12, 23, 25, 30, 36, 37, 41, 47, 58, 59, 61, 63], "expval": [2, 18], "other": [2, 3, 10, 11, 12, 13, 15, 17, 20, 22, 25, 30, 32, 34, 35, 36, 37, 39, 40, 41, 47, 51, 59, 61, 65], "appendresult": 2, "globalregisternam": [2, 18], "classic": [2, 5, 7, 10, 11, 13, 17, 19, 22, 23, 25, 26, 30, 32, 36, 40, 41, 47, 53, 54, 55, 58, 59, 62], "sequentialdata": 2, "sequenti": [2, 3, 18, 35, 41], "collat": [2, 3], "": [2, 3, 6, 9, 10, 11, 12, 14, 15, 18, 25, 28, 32, 34, 35, 39, 40, 41, 44, 46, 47, 48, 49, 50, 51, 52, 54, 55, 57, 59, 61, 62, 63, 65], "holist": 2, "nullari": 2, "precomputedexp": 2, "__global__": [2, 3, 18, 35], "has_expect": 2, "string_view": [2, 18, 58], "anoth": [2, 21, 22, 32, 37, 43, 47, 49, 51, 59], "register_nam": [2, 3, 18], "tandem": [2, 50], "to_map": [2, 18], "regnam": 2, "merg": [2, 55], "necessari": [2, 34, 36, 37, 47, 51, 55, 59, 61], "document": [2, 3, 15, 16, 17, 25, 33, 34, 35, 57, 58, 59, 61, 67], "exp_val_z": 2, "deprec": [2, 3, 14, 33, 36, 37], "probabl": [2, 3, 6, 9, 12, 18, 41, 43, 51, 53], "most_prob": [2, 3, 8, 21, 41, 43, 53], "most": [2, 3, 10, 16, 18, 32, 35, 41, 43, 47, 55, 59, 61, 62, 67], "ostream": 2, "output": [2, 3, 5, 7, 22, 34, 38, 41, 55, 59, 61, 65], "stream": [2, 23], "extract": [2, 3, 5, 18, 20, 21, 30, 32, 41, 54, 55, 59, 61], "unord": 2, "get_margin": [2, 18], "marginalindic": [2, 18], "margin": [2, 12], "those": [2, 18, 22, 32, 36, 37, 55], "subset": [2, 3, 7, 18, 22, 30, 32], "rvalu": 2, "refer": [2, 10, 15, 18, 22, 23, 30, 32, 34, 35, 36, 47, 52, 59, 61], "newbitstr": 2, "oldbitstr": 2, "process": [2, 3, 11, 14, 17, 18, 23, 28, 34, 35, 36, 37, 40, 47, 50, 53, 55], "rang": [2, 4, 6, 7, 8, 10, 11, 12, 13, 14, 21, 22, 29, 30, 35, 36, 39, 43, 44, 50, 52, 61, 65], "const_iter": 2, "cbegin": 2, "cend": 2, "has_even_par": 2, "pariti": 2, "extens": [2, 17, 18, 24, 30, 33, 53, 58, 61, 63, 65], "concret": [2, 3, 10, 18, 41, 46], "describ": [2, 3, 9, 12, 28, 30, 34, 49, 53, 58, 59, 61], "effici": [2, 37], "manner": [2, 18, 58], "client": [2, 18, 35, 59], "remain": [2, 3, 29, 47, 51, 59], "gpu": [2, 3, 4, 5, 7, 8, 11, 15, 16, 17, 23, 36, 38, 40, 43, 44, 45, 58, 59, 63, 65, 67], "devic": [2, 3, 7, 9, 12, 18, 21, 22, 25, 29, 34, 35, 36, 37, 41, 47, 54, 55, 58, 61], "cpu": [2, 7, 8, 9, 10, 11, 12, 15, 33, 35, 36, 40, 41, 43, 44, 50, 51, 55, 59, 61, 65], "memori": [2, 7, 19, 22, 23, 30, 32, 35, 36, 37, 40, 43, 50, 55, 61], "primari": [2, 3, 18, 30, 58], "goal": [2, 10], "minim": [2, 10, 12, 13, 14, 15, 46, 54, 59, 61, 65], "transfer": [2, 37], "subclass": [2, 18, 58], "cusvstat": 2, "scalartyp": 2, "remotesimulationst": 2, "nvqir": [2, 15, 55, 56, 58], "mpssimulationst": 2, "tensornetsimulationst": 2, "made": [2, 10, 41, 51, 61], "up": [2, 3, 5, 10, 11, 20, 26, 37, 40, 46, 50, 51, 52, 53, 54, 55, 58, 61], "extent": [2, 3, 37], "enum": 2, "precis": [2, 3, 11, 13, 35, 37, 53], "enumer": [2, 3, 12, 21, 43], "fp32": [2, 3, 35, 36, 37], "fp64": [2, 3, 13, 14, 33, 35, 36, 37], "simulation_precis": 2, "possibl": [2, 5, 12, 17, 32, 53, 61, 63], "float": [2, 3, 4, 5, 6, 7, 8, 10, 12, 13, 14, 18, 21, 22, 25, 29, 35, 36, 37, 46, 52, 54, 58], "tensorstatedata": 2, "dimens": [2, 3, 4, 8, 10, 18, 52, 54], "state_data": 2, "variant": [2, 25], "differ": [2, 3, 5, 6, 7, 11, 12, 32, 34, 35, 36, 40, 41, 47, 50, 51, 59, 61], "custatevec": [2, 35, 36, 37, 58], "attempt": 2, "care": [2, 18], "taken": [2, 8], "ensur": [2, 55, 57, 59, 61], "comparison": [2, 5], "compat": [2, 3, 24, 37, 59], "registeredtyp": 2, "declar": [2, 18, 22, 23, 25, 55, 58], "themselv": [2, 34, 39], "plugin": [2, 16, 57, 59, 61, 67], "myinterfac": 2, "column": [2, 3], "upon": [2, 4, 32, 41, 47, 53, 61], "destruct": 2, "rawdata": 2, "intern": [2, 3, 36], "modifi": [2, 21, 22, 25, 29, 32, 37, 54, 61], "correct": [2, 11, 12, 21, 40, 47, 59, 61], "j": [2, 3, 6, 8, 10, 11, 12, 21, 22, 26, 50, 52, 59], "minimal_eigenvalu": [2, 3], "eigenvalu": [2, 3, 10, 37, 54], "thei": [2, 3, 4, 10, 22, 30, 32, 40, 53, 54, 59, 61], "set_zero": 2, "print": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 18, 21, 30, 35, 36, 41, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 59, 65], "seen": [2, 5], "manag": [2, 35, 36, 59, 61], "instruct": [2, 23, 25, 27, 32, 34, 35, 37, 47, 48, 54, 55, 59, 61, 65], "control": [2, 3, 6, 10, 11, 15, 17, 20, 21, 22, 23, 25, 27, 29, 30, 31, 32, 34, 36, 39, 40, 43, 45, 47, 48, 51, 53, 54, 55, 58, 61], "flow": [2, 7, 17, 18, 22, 31, 40, 55], "path": [2, 3, 34, 55, 58, 59, 61], "thu": [2, 35, 36, 37, 53, 55], "might": [2, 20, 25, 32, 33, 35, 36, 49], "produc": [2, 3, 10, 18, 21, 26, 27, 32, 39, 41, 48, 55, 58], "elementtyp": 2, "is_integral_v": 2, "is_signed_v": 2, "increment": [2, 50], "exclus": [2, 5], "stop": [2, 41, 61], "step": [2, 5, 7, 11, 21, 55, 59, 63, 65], "reach": [2, 50], "quantumkernel": [2, 18, 29], "arg": [2, 3, 7, 11, 12, 18, 20, 25, 29, 36, 41, 55, 61], "is_invocable_v": 2, "draw": [2, 3, 4, 5, 9, 11, 12, 41, 43], "utf": [2, 3], "8": [2, 3, 7, 8, 10, 11, 12, 13, 14, 18, 21, 22, 23, 33, 34, 35, 36, 37, 47, 50, 51, 52, 54, 55, 59, 61, 65], "usag": [2, 36, 50], "iostream": [2, 35, 39, 41, 43], "bell_pair": [2, 3], "__qpu__": [2, 18, 21, 22, 29, 35, 36, 39, 41, 43, 44, 46, 47, 48, 49, 51, 52, 54, 55, 65], "mz": [2, 3, 5, 6, 12, 18, 20, 21, 32, 34, 35, 36, 39, 41, 43, 44, 47, 48, 49, 50, 51, 53, 55, 65], "cout": [2, 35, 41, 43], "q0": [2, 3, 4, 5, 9, 11, 32], "q1": [2, 3, 4, 5, 9, 11, 32], "ry": [2, 3, 4, 6, 7, 8, 18, 21, 22, 25, 27, 35, 36, 46, 54], "59": [2, 3, 10, 18, 21, 36, 46], "callabl": [2, 3, 17, 18, 20, 21, 22, 39, 46, 48], "trivial": [2, 18, 36, 44, 46, 62], "signatur": [2, 3, 18, 20, 22, 49, 55], "evalu": [2, 3, 6, 18, 35, 37, 46], "without": [2, 3, 18, 22, 29, 34, 37, 43, 47, 51, 59, 61, 65], "regard": 2, "depth": [2, 66], "etc": [2, 22, 23, 36, 40, 54, 58, 59, 61, 65], "kraus_op": 2, "krau": [2, 3, 9, 51], "initializer_list": 2, "initlist": 2, "adjoint": [2, 11, 20, 21, 25, 29, 32, 55], "flatten": 2, "nrow": [2, 7], "ncol": 2, "kraus_channel": [2, 51], "channel": [2, 3, 9, 12, 51, 61], "action": [2, 18, 21, 22, 61], "matric": [2, 3, 37], "amplitude_damping_channel": [2, 51], "bit_flip_channel": [2, 51], "depolarization_channel": [2, 9, 51], "phase_flip_channel": [2, 51], "inputlist": 2, "lvalu": 2, "make": [2, 3, 5, 11, 18, 36, 37, 51, 52, 53, 54, 55, 58, 59, 61, 63, 65], "get_op": 2, "push_back": [2, 22, 43], "autom": [2, 58], "creation": [2, 17, 31, 54, 58], "damp": [2, 51], "error": [2, 6, 9, 15, 25, 32, 34, 35, 37, 40, 47, 51, 59, 61], "phase": [2, 3, 11, 25, 47, 51], "depolar": [2, 3, 9, 51], "densiti": [2, 3, 9, 12, 33, 35, 37, 51], "add_channel": [2, 3, 9, 12, 51], "quantumop": 2, "get_channel": [2, 3], "relev": [2, 4, 7, 12, 14, 28, 37], "kernel_build": [2, 20], "kernel_builder_bas": 2, "kernelbuildertyp": 2, "mlir": [2, 3, 15, 36, 55, 56, 57, 59], "getargu": [2, 20, 57], "quakevalu": [2, 3, 20], "isargstdvec": 2, "otherwis": [2, 3, 5, 37, 41], "getnumparam": [2, 20], "qalloc": [2, 3, 20, 34, 35, 36, 50], "qvec": [2, 32, 34], "veq": [2, 3, 32, 55], "blockargu": 2, "object": [2, 3, 8, 10, 12, 18, 22, 32, 36, 41, 52, 54, 55], "simplic": 2, "impli": [2, 3, 37], "goe": [2, 23, 43], "scope": [2, 22, 23, 30, 55, 57], "befor": [2, 10, 34, 42, 47, 51, 54, 59, 61, 63], "mai": [2, 3, 5, 10, 18, 20, 22, 23, 25, 29, 30, 34, 35, 36, 37, 40, 41, 42, 44, 47, 49, 54, 59, 61, 63, 65], "garbag": 2, "constantv": 2, "val": [2, 12, 47], "swap": [2, 21, 47], "mod": [2, 25], "is_same_v": 2, "perform": [2, 5, 7, 11, 12, 13, 16, 18, 21, 34, 37, 41, 43, 47, 49, 50, 53, 57, 58, 59, 61, 65, 67], "fredkin": 2, "between": [2, 3, 6, 10, 12, 13, 22, 32, 35, 39, 40, 41, 47, 50, 51, 61], "meant": [2, 17, 44], "thin": [2, 3], "wrapper": [2, 3, 36], "around": [2, 3, 5, 12, 18, 43, 51, 63, 65], "instanc": [2, 3, 18, 20, 25, 30, 35, 36, 37, 40, 61], "quak": [2, 3, 10, 15, 31, 55, 57], "dialect": [2, 3, 55, 57], "arithmet": [2, 22, 23, 54], "getvalu": 2, "actual": [2, 12, 18, 41, 58], "implicitlocopbuild": 2, "arith": [2, 32, 55], "constantfloatop": 2, "canvalidatenumel": 2, "stdvectyp": 2, "do": [2, 11, 12, 25, 27, 30, 32, 35, 36, 37, 39, 40, 48, 53, 55, 59, 61, 62, 63, 65], "loop": [2, 3, 10, 19, 30, 39, 47, 50, 52, 54, 55], "know": [2, 32, 53], "bound": [2, 3, 12, 54], "startidx": [2, 3], "subscript": [2, 3, 34, 35], "stdvec": [2, 32, 55], "constants": 2, "isstdvec": 2, "getrequiredel": 2, "veqtyp": 2, "divid": [2, 10], "invers": [2, 11, 21], "so": [2, 6, 8, 10, 12, 18, 34, 36, 37, 43, 48, 53, 54, 55, 57, 58, 59, 61, 65], "friend": 2, "write": [2, 3, 42, 47, 53, 54, 57, 61, 63], "u": [2, 4, 5, 8, 10, 11, 13, 21, 22, 26, 27, 39, 40, 41, 49, 50, 51, 53, 54, 55], "wai": [2, 3, 5, 18, 29, 32, 41, 59], "code": [2, 3, 5, 10, 11, 13, 17, 18, 20, 21, 22, 23, 26, 27, 29, 30, 32, 34, 35, 36, 37, 41, 46, 47, 48, 50, 51, 53, 54, 55, 57, 58, 59, 62, 63, 65], "mlircontext": 2, "ctx": [2, 7, 57], "f": [2, 5, 12, 21, 22, 43, 46, 54, 59, 65], "high": [2, 12, 50, 55], "serv": [2, 3, 22, 30, 35, 57, 59], "work": [2, 11, 12, 15, 18, 35, 36, 50, 54, 56, 59, 61, 62, 65], "subtyp": 2, "possibli": [2, 12, 22], "deleg": [2, 35, 58, 61], "third": [2, 3, 54], "parti": [2, 54], "immut": 2, "mutabl": [2, 18], "gradient": [2, 4, 7, 35, 52, 54], "df": [2, 12], "dx_i": 2, "scalar": [2, 18], "queri": [2, 5, 18, 28, 36, 43, 46], "whether": [2, 3, 59, 61], "strategi": [2, 18, 23, 29, 54, 58], "parameter": [2, 3, 10, 13, 18, 20, 22, 25, 35, 40, 46, 48, 50, 54], "left": [2, 5, 6, 10, 11, 47, 58, 61], "thing": [2, 49, 54], "max": [2, 8, 15, 35, 37, 47, 52], "cobyla": [2, 3, 4, 8, 13, 14, 18, 52, 54], "opt": [2, 22, 55, 57, 59, 61], "assert": [2, 21, 22], "requiresgradi": [2, 18], "algo": 2, "opt_val": [2, 35, 52, 54], "opt_param": [2, 18, 35, 52, 54], "dx": [2, 18], "virtual": [2, 16, 18, 35, 36, 41, 46, 50, 58, 59, 67], "achiev": [2, 10, 11, 18, 34, 35, 49, 54], "dim": [2, 35], "optimizable_funct": [2, 18], "opt_funct": [2, 18, 35], "variat": [2, 4, 7, 10, 14, 15, 18, 45], "ptrtoown": 2, "conveni": [2, 11, 26, 32, 54, 59, 61], "jdx": 2, "tensoridx": 2, "get_tensor": 2, "just": [2, 5, 6, 10, 17, 31, 41, 42, 43, 48, 53, 55, 61], "rank": [2, 3, 36, 44, 48, 50], "get_num_tensor": 2, "get_num_qubit": [2, 28], "get_precis": [2, 3], "is_on_gpu": [2, 3], "to_host": 2, "hostptr": 2, "numel": 2, "basisst": 2, "host": [2, 19, 21, 22, 23, 26, 30, 35, 36, 37, 46, 63, 65], "leverag": [2, 3, 18, 20, 22, 25, 29, 30, 37, 48, 52, 54, 55, 58, 62], "separ": [2, 37, 59, 61], "mapper": 2, "inherit": [2, 19, 23, 36], "updat": [2, 18, 34, 47, 59, 65], "protect": [2, 30, 58], "getexpectedvalu": 2, "central_differ": [2, 18, 54], "forward_differ": 2, "parameter_shift": 2, "prescrib": 2, "kernelt": 2, "argsmapp": [2, 18], "setarg": 2, "save": [2, 7, 35, 36, 41, 50, 55, 61, 63], "nvqc": [2, 33, 35], "setkernel": 2, "been": [2, 3, 34, 35, 40, 41, 47, 59, 61], "accept": [2, 3, 39, 59, 61, 65], "have": [2, 3, 5, 10, 11, 12, 16, 18, 32, 35, 36, 37, 41, 43, 47, 50, 51, 53, 57, 59, 61, 62, 63, 65, 67], "funcatx": [2, 3], "func": [2, 18, 32, 55, 57], "clone": [2, 7, 30, 57, 59], "deriv": [2, 5, 18, 53], "exp_h": [2, 18], "order": [2, 10, 18, 26, 34, 37, 41, 46, 51], "forward": [2, 7], "approxim": [2, 10, 15, 37, 41, 45], "registri": [2, 61], "unit": [2, 3, 17, 22, 23, 25, 28, 30, 34, 40, 53, 63], "express": [2, 16, 18, 19, 20, 21, 23, 26, 40, 48, 49, 55, 67], "certain": [2, 30, 35, 36, 37, 58, 59, 61], "logic": [2, 5, 28, 30, 36], "connect": [2, 7, 10, 16, 23, 28, 30, 32, 47, 59, 67], "queue": [2, 18, 35, 47], "enqueu": 2, "relat": [2, 10, 55], "quantum_platform": [2, 3, 28, 36, 46, 55], "baseremoterestqpu": 2, "baseremotesimulatorqpu": 2, "_qpuid": 2, "setid": 2, "thread": [2, 3, 23, 36, 37, 46, 50, 58], "getexecutionthreadid": 2, "getnumqubit": 2, "getconnect": 2, "issimul": 2, "supportsconditionalfeedback": 2, "feedback": [2, 23, 40, 61], "remotecap": 2, "getremotecap": 2, "capabl": [2, 35, 37, 50, 59, 61], "setshot": 2, "_nshot": 2, "noth": 2, "wish": [2, 35, 36, 46, 61], "isemul": 2, "local": [2, 3, 15, 34, 35, 36, 41, 44, 47, 55, 59, 60, 62], "emul": [2, 3, 34, 47], "quantumtask": 2, "setexecutioncontext": 2, "resetexecutioncontext": 2, "reset": [2, 3, 18, 21, 23, 37, 58], "launchkernel": 2, "kernelfunc": 2, "uint64_t": 2, "launch": [2, 18, 36, 37, 61, 65], "pack": 2, "launchserializedcodeexecut": 2, "serializedcodeexecutioncontext": 2, "serializecodeexecutionobject": 2, "onrandomseedset": 2, "notifi": 2, "let": [2, 5, 6, 9, 10, 11, 12, 13, 25, 32, 39, 40, 41, 44, 46, 48, 49, 50, 51, 52, 53, 54, 55, 61, 62, 63, 65], "basenvcfsimulatorqpu": 2, "submit": [2, 34, 35, 47, 61], "nvcf": 2, "realiz": [2, 53], "intend": [2, 17, 18, 20, 59], "popul": [2, 43], "platformqpu": 2, "qubitconnect": [2, 28], "fetch": 2, "supports_task_distribut": 2, "multipl": [2, 12, 14, 16, 25, 34, 36, 37, 40, 41, 47, 49, 53, 67], "parallel": [2, 17, 23, 37, 41, 61, 65], "qpu_id": [2, 3, 6, 18, 28, 35, 36, 41, 50], "get_shot": 2, "getter": 2, "onc": [2, 11, 12, 20, 34, 35, 37, 40, 41, 47, 59, 61, 63, 65], "set_shot": 2, "clear_shot": 2, "remov": [2, 32, 33, 35, 36, 37, 61], "numshot": 2, "setter": 2, "set_exec_ctx": 2, "get_exec_ctx": 2, "reset_exec_ctx": 2, "num_qpu": [2, 3, 6, 28, 35, 36, 46], "is_simul": [2, 28], "supports_conditional_feedback": 2, "get_current_qpu": [2, 28], "set_current_qpu": [2, 28], "device_id": [2, 28], "is_remot": [2, 3, 28], "qpuid": [2, 28, 36], "is_emul": [2, 3, 28], "set_nois": [2, 3, 51], "get_remote_cap": 2, "applic": [2, 5, 10, 11, 12, 13, 15, 18, 25, 29, 34, 37, 40, 41, 45, 61, 62, 65, 66], "reset_nois": 2, "turn": [2, 7, 11, 35, 42, 53, 58], "off": [2, 3, 7, 11, 35, 36, 59], "enqueueasynctask": 2, "kernelexecutiontask": 2, "launchvq": 2, "kernelarg": 2, "n_param": [2, 52, 54], "vqe": [2, 3, 10, 13, 35, 52, 54], "settargetbackend": 2, "resetlogstream": 2, "log": [2, 3, 16, 35, 59, 61, 67], "getlogstream": 2, "setlogstream": 2, "logstream": 2, "list_platform": 2, "structur": [2, 3, 7, 10, 18, 20, 24, 26, 28, 30, 36, 37, 55, 57, 58], "boolean": [2, 20], "field": [2, 10, 36], "initvalu": 2, "stateoverlap": 2, "serializedcodeexec": 2, "command": [2, 35, 36, 37, 41, 43, 44, 46, 47, 50, 58, 59, 61, 62, 63, 65], "entir": [2, 32, 48, 54, 58], "forth": 2, "commun": [2, 18, 34, 36, 37, 59], "ultim": [2, 55, 58], "what": [2, 3, 10, 15, 38, 50, 53, 58], "ad": [2, 12, 16, 18, 34, 35, 48, 51, 55, 59, 61, 63, 65, 67], "promis": 2, "qubitedg": [2, 28], "num_available_gpu": [2, 3, 41, 50], "set_random_se": [2, 3, 7, 8, 10, 12, 37, 52, 54], "caller": [2, 22], "unset_nois": [2, 3, 51], "dealloc": [2, 23, 30, 58], "mpi": [2, 16, 36, 37, 44, 48, 50, 65, 67], "built": [2, 4, 11, 16, 34, 37, 40, 41, 44, 51, 54, 59, 63, 65, 67], "against": [2, 16, 34, 59, 67], "argc": [2, 21, 41, 59, 65], "argv": [2, 21, 41, 59, 65], "program": [2, 15, 17, 20, 22, 25, 30, 31, 34, 35, 36, 37, 38, 40, 47, 48, 50, 51, 55, 59, 61, 63, 65], "is_initi": [2, 3, 44, 48], "alreadi": [2, 3, 59, 61, 65], "final": [2, 3, 4, 36, 46, 48, 50, 54, 55, 58, 59], "num_rank": [2, 3, 50], "all_gath": [2, 3], "gather": [2, 3, 21, 41, 53], "fit": [2, 59], "come": [2, 23, 35, 47], "all_reduc": 2, "binaryfunct": 2, "localvalu": 2, "reduc": [2, 6, 12, 37], "rootrank": [2, 3], "make_kernel": [3, 20, 34, 35, 36, 50], "els": [3, 7, 20, 36, 37, 41, 59, 65], "int_valu": 3, "float_valu": 3, "pykernel": 3, "argtypelist": 3, "programmat": 3, "str": [3, 8, 12, 34, 36, 41, 43, 47, 53], "argument_count": 3, "alia": [3, 30], "pykerneldecor": 3, "verbos": [3, 38, 55, 59, 62], "modul": [3, 7, 37, 41, 54, 55, 59], "none": [3, 7, 21, 22, 37], "funcsrc": 3, "locat": [3, 34, 36, 59, 61], "overrideglobalscopedvar": 3, "decor": [3, 22, 39], "lower": [3, 55, 58], "ast": 3, "jit": 3, "executionengin": 3, "__call__": 3, "__str__": 3, "from_json": 3, "jstr": 3, "overridedict": 3, "convert": [3, 18, 46, 55], "json": [3, 34, 36, 47, 61], "to_json": 3, "self": [3, 7, 10, 22, 59, 61], "reconstruct": 3, "elsewher": 3, "type_to_str": 3, "clean": 3, "kwarg": 3, "languag": [3, 15, 16, 19, 22, 23, 24, 25, 30, 31, 36, 40, 48, 53, 55, 58, 62, 67], "attribut": [3, 22, 48, 55], "coprocessor": [3, 18, 22], "shots_count": [3, 5, 6, 8, 9, 12, 34, 41, 44, 48, 50], "1000": [3, 7, 9, 12, 18, 34, 41, 48, 50, 53, 65], "over": [3, 9, 18, 30, 41, 47, 51, 52, 54, 58, 61], "ndarrai": [3, 7, 9], "leav": [3, 9, 34, 47, 61], "doesn": 3, "firstfloat": 3, "secondfloat": 3, "kei": [3, 8, 10, 11, 12, 27, 34, 35, 58, 61, 65], "nois": [3, 9, 18, 28, 34, 47, 51], "model": [3, 9, 15, 17, 18, 20, 22, 25, 30, 31, 32, 34, 36, 47, 51, 55, 58, 61, 65], "dictionari": [3, 12, 18, 41, 48, 54], "sampleresult": [3, 41, 48, 58], "sample_async": [3, 6, 18, 36, 41, 47], "_mlir_lib": 3, "_quakedialect": 3, "cudaq_runtim": 3, "asyncsampleresult": [3, 47], "platform": [3, 15, 16, 17, 25, 31, 33, 34, 35, 37, 41, 46, 50, 55, 58, 59, 61, 65, 67], "Will": [3, 27, 41], "whose": [3, 7, 10, 13, 18, 23, 35, 46, 53], "identif": 3, "spin_oper": [3, 10, 41, 46, 54], "spinoper": [3, 7, 8, 10, 14, 41, 46, 50, 54], "everi": [3, 10, 12, 35, 36, 40, 41, 47, 48, 59, 65], "nest": [3, 36], "hermitian": 3, "calcul": [3, 4, 5, 6, 7, 35, 41, 47, 50, 54], "observeresult": [3, 41, 54], "observe_async": [3, 18, 35, 50], "asyncobserveresult": 3, "arg0": [3, 55], "import": [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 21, 26, 34, 35, 36, 37, 39, 41, 43, 44, 46, 47, 48, 50, 51, 52, 53, 54, 55, 59, 65], "numpi": [3, 5, 7, 8, 9, 10, 11, 12, 13, 14, 21, 47, 50, 51, 52, 59], "prepar": [3, 6, 7, 11, 12, 13, 43, 46, 48, 50, 52], "select": [3, 7, 13, 37, 41, 44, 46, 61, 63], "get_state_async": 3, "asyncstateresult": 3, "parameter_count": [3, 8, 10, 13, 14, 50, 52, 54], "argument_mapp": [3, 10], "gradient_strategi": [3, 54], "arg1": 3, "format": [3, 7, 18, 21, 30], "ascii": 3, "latex": 3, "def": [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 18, 21, 22, 27, 29, 35, 36, 39, 41, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 61, 65], "cx": [3, 12, 20, 34, 35, 43, 50, 65], "translat": [3, 18, 53, 55], "qir": [3, 55, 58], "adapt": [3, 10, 16, 67], "openqasm2": 3, "openqasm": 3, "moduleid": [3, 55], "llvmdialectmodul": [3, 55], "source_filenam": [3, 55], "opaqu": [3, 30, 55], "__nvqpp__mlirgen__function_variable_qreg": 3, "_z13variable_qregv": 3, "local_unnamed_addr": [3, 55], "tail": [3, 55], "__quantum__rt__qubit_allocate_arrai": [3, 55], "i64": [3, 55], "__quantum__qis__mz": [3, 55], "9": [3, 7, 8, 12, 18, 22, 23, 55, 59, 61], "7": [3, 4, 6, 7, 8, 10, 11, 12, 16, 18, 22, 23, 25, 30, 36, 50, 55, 59, 61, 67], "__quantum__rt__qubit_release_arrai": [3, 55], "ret": [3, 55], "has_target": 3, "get_target": [3, 6, 35, 36, 46, 65], "rais": 3, "set_target": [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 34, 35, 36, 37, 41, 43, 44, 46, 47, 50, 51, 58], "reset_target": 3, "initialize_cudaq": 3, "environ": [3, 9, 34, 35, 36, 42, 44, 47, 57, 59, 61, 65], "detect": [3, 41, 50, 59, 61], "simulationprecis": 3, "underyl": 3, "properti": [3, 5, 32], "noindex": 3, "infrastructur": [3, 16, 36, 57, 59, 67], "descript": [3, 35, 37, 58, 59, 61], "featur": [3, 11, 16, 22, 59, 61, 65, 67], "activ": [3, 7, 15, 36, 37, 59, 61, 65], "consist": [3, 41], "physic": [3, 10, 17, 23, 30, 32, 34, 36, 37, 47, 53], "0101": [3, 52], "1010": [3, 52], "consol": [3, 35, 42, 59], "cupi": [3, 61], "gettensor": 3, "compris": 3, "tensori": 3, "mlirvalu": 3, "As": [3, 10, 17, 23, 24, 30, 36, 37, 39, 53, 54, 57], "hold": [3, 54], "__add__": 3, "runtimeerror": 3, "new_valu": 3, "5": [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 21, 22, 23, 25, 26, 29, 30, 35, 36, 37, 43, 44, 46, 47, 50, 51, 52, 54, 55, 59, 61, 67], "__radd__": 3, "__sub__": 3, "__rsub__": 3, "__neg__": 3, "__mul__": 3, "__rmul__": 3, "__getitem__": 3, "you": [3, 5, 11, 12, 15, 16, 18, 34, 35, 37, 41, 43, 47, 48, 50, 51, 53, 54, 55, 57, 58, 59, 61, 62, 65, 67], "complexmatrix": 3, "lowest": 3, "__eq__": 3, "togeth": [3, 12, 15, 37, 55, 65], "__iter__": 3, "through": [3, 5, 7, 9, 18, 34, 39, 42, 44, 48, 51, 54, 58, 59, 61, 65], "chunk_count": 3, "d1": 3, "d2": [3, 46], "d3": 3, "receiv": [3, 18], "while": [3, 22, 40, 41, 47, 55, 59, 61], "0j": [3, 6, 8, 10, 41], "get_qubit_count": 3, "get_term_count": [3, 14], "qubit_count": [3, 5, 7, 9, 10, 11, 13, 14, 36, 39, 41, 43, 44, 50, 52, 65], "term_count": [3, 50], "4097292269": 3, "ith": 3, "scipi": [3, 12, 13, 14, 54], "csr_arrai": 3, "print_coeffici": 3, "termin": [3, 50, 61], "At": [3, 59, 61], "directli": [3, 17, 18, 23, 30, 32, 55, 61, 65], "c_if": [3, 20], "dure": [3, 4, 9, 18, 34, 37, 59, 61], "__len__": 3, "equival": [3, 10, 36, 37, 41], "metadata": [3, 13, 55], "experi": [3, 12, 34, 47, 59, 61], "expectation_z": 3, "get_marginal_count": [3, 12], "marginal_indic": 3, "get_register_count": 3, "get_sequential_data": 3, "item": [3, 7, 12], "frequent": 3, "proport": 3, "kick": [3, 36], "pattern": [3, 17, 18, 22, 31, 55, 57], "sub_term": 3, "favor": 3, "get_spin": 3, "accessor": 3, "optimizationresult": 3, "gradientdesc": 3, "initial_paramet": [3, 4, 8, 10, 52, 54], "lower_bound": 3, "max_iter": [3, 54], "maximum": [3, 37], "requires_gradi": 3, "upper_bound": 3, "upper": 3, "neldermead": [3, 8, 10], "lbfg": [3, 18, 35, 54], "centraldiffer": [3, 54], "parameter_vector": [3, 10, 35, 54], "loss": 3, "forwarddiffer": 3, "parametershift": 3, "krauschannel": [3, 9, 51], "__init__": [3, 7, 22], "bitflipchannel": [3, 12, 51], "decoher": [3, 9, 51], "Its": [3, 30, 37, 53, 55], "vice": 3, "versa": 3, "180": [3, 51], "therebi": [3, 18, 55], "k_0": [3, 9], "k_1": [3, 9], "therefor": [3, 10, 11, 30, 55, 57], "phaseflipchannel": [3, 51], "untouch": 3, "depolarizationchannel": [3, 9, 51], "mixtur": 3, "k_2": 3, "k_3": 3, "2x2": [3, 37], "decai": [3, 9, 51], "And": [3, 10, 32], "behav": 3, "free": [3, 4, 10, 18, 20, 21, 22, 23, 25, 27, 29, 34, 35, 39, 48, 52, 54, 55, 58, 61], "75": [3, 11, 14], "proabil": 3, "uniform": [3, 8, 10, 12, 18, 21, 41, 50, 52], "amplitudedampingchannel": [3, 51], "dissip": [3, 51], "energi": [3, 13, 14, 18, 35, 46, 51, 54], "due": [3, 9, 13, 18, 37, 41, 51, 53], "interact": [3, 28, 51, 61], "ii": [3, 10], "ground": [3, 13, 35, 51, 53, 54], "krausoper": [3, 51], "ki": 3, "dag": [3, 27], "col_count": 3, "row_count": 3, "scatter": 3, "concaten": 3, "arg2": 3, "below": [4, 5, 7, 10, 11, 13, 18, 34, 35, 36, 37, 41, 47, 50, 52, 54, 55, 59, 61, 65], "hybrid": [4, 15, 54, 62, 65], "algorithm": [4, 10, 11, 13, 15, 17, 20, 22, 31, 32, 35, 36, 37, 41, 43, 45, 46, 49, 54, 61], "involv": [4, 37, 50, 55], "bloch": [4, 53], "ket": [4, 5, 6, 11, 41, 53], "packag": [4, 5, 7, 12, 14, 59, 61, 65], "our": [4, 5, 9, 10, 16, 32, 34, 39, 41, 43, 47, 48, 49, 50, 51, 53, 54, 55, 59, 61, 62, 63, 65, 67], "workflow": [4, 7, 15, 18, 45, 55, 59, 62], "nvidia": [4, 5, 6, 7, 8, 10, 11, 13, 14, 15, 16, 17, 23, 33, 37, 41, 43, 44, 46, 50, 58, 59, 61, 63, 65, 67], "rx": [4, 6, 7, 8, 10, 12, 25, 29, 50, 52], "hamiltonian": [4, 6, 7, 8, 9, 10, 13, 14, 21, 35, 36, 37, 41, 46, 52, 54], "intial": 4, "q2": [4, 11], "build": [4, 10, 12, 13, 15, 16, 20, 25, 26, 38, 40, 41, 46, 52, 53, 54, 57, 58, 61, 62, 67], "statevector": [4, 11, 50, 53, 65], "bra": [4, 6, 41], "cost_valu": [4, 8], "expectation_valu": [4, 46], "demonstr": [4, 5, 11, 13, 17, 18, 20, 36, 41, 44, 49, 55], "initial_cost_valu": 4, "suit": [4, 54, 61], "alogrithm": 4, "6": [4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 21, 22, 23, 25, 26, 30, 34, 35, 36, 37, 46, 47, 54, 55, 61, 67], "pip": [4, 7, 12, 13, 14, 36, 37, 59, 61, 65], "instal": [4, 7, 12, 13, 14, 15, 16, 34, 37, 55, 57, 58, 62, 63, 67], "matplotlib": [4, 7, 8, 12, 13, 14], "plot": [4, 7, 8, 12, 13, 14], "decreas": [4, 43], "procedur": [4, 13], "pyplot": [4, 7, 8, 12, 13, 14], "plt": [4, 7, 8, 12, 13, 14], "x_valu": [4, 8], "len": [4, 6, 7, 8, 10, 11, 12, 14, 21, 30, 36, 41, 43, 47, 50, 65], "y_valu": [4, 8], "xlabel": [4, 7, 8, 13, 14], "epoch": [4, 7, 8, 13, 14], "ylabel": [4, 7, 8, 13, 14], "text": [4, 5, 11, 12], "39": [4, 8, 12, 14], "longrightarrow": 5, "balanc": 5, "regardless": 5, "ouput": 5, "question": 5, "would": [5, 10, 11, 32, 50, 53, 59, 61, 63], "answer": [5, 11], "solv": [5, 6, 10, 11, 40], "find": [5, 10, 12, 13, 15, 34, 35, 36, 53, 54, 55, 59, 61], "treat": [5, 36], "snippet": [5, 35, 36, 46, 55, 61], "black": 5, "box": [5, 9], "don": [5, 11, 16, 18, 35, 67], "access": [5, 11, 16, 18, 23, 34, 35, 36, 44, 48, 49, 50, 53, 58, 67], "elif": 5, "abov": [5, 10, 11, 18, 20, 25, 35, 36, 37, 41, 46, 47, 49, 53, 55, 58, 59, 61, 63, 65], "That": [5, 18, 65], "twice": 5, "claim": 5, "evalul": 5, "advantag": [5, 61], "go": [5, 30, 36, 48, 59, 61], "symbol": 5, "OR": [5, 47], "rule": 5, "addit": [5, 11, 18, 35, 39, 40, 43, 50, 59, 65], "modulo": 5, "oplus5": 5, "_": [5, 7, 12, 43], "8_": 5, "oplus4": 5, "9_": 5, "quick": [5, 15, 34, 63], "suppos": [5, 62], "yield": [5, 53, 65], "sequenc": [5, 10, 32, 40], "u_f": 5, "align": [5, 11, 55], "remark": 5, "becaus": [5, 32, 37, 43, 47, 59, 61, 65], "overlin": 5, "bar": [5, 10, 11, 12], "top": [5, 12, 36, 58, 62], "denot": [5, 11, 22, 24], "prove": [5, 53], "shall": [5, 6, 53], "tfrac": [5, 53], "In": [5, 9, 10, 12, 18, 22, 32, 34, 36, 37, 39, 41, 43, 46, 47, 48, 51, 53, 54, 57, 58, 59], "summari": 5, "unchang": [5, 9, 55], "simultan": [5, 35], "mechan": [5, 18, 20, 26, 30, 32, 36, 42, 53, 57], "exploit": [5, 37], "abil": [5, 23, 44, 55], "aim": [5, 10, 43], "neq": 5, "diagram": [5, 10, 11, 34, 47], "psi_0": 5, "tag": [5, 11, 59, 61], "psi_1": 5, "h_1h_0": 5, "frac": [5, 6, 10, 11, 12], "psi_2": 5, "drop": 5, "figur": [5, 7, 11, 55], "further": [5, 25, 32, 39, 41, 55, 58, 65], "rememb": 5, "psi_": 5, "pm": 5, "practic": [5, 12, 51], "fx": 5, "shown": [5, 36, 37], "qubit_0": [5, 10], "want": [6, 10, 12, 32, 35, 36, 55, 58, 59, 61, 63, 65], "quantiti": 6, "u_": 6, "qquad": 6, "x_1x_2": 6, "fact": [6, 11, 32], "dagger": [6, 9, 27, 53], "simpl": [6, 9, 20, 23, 35, 36, 39, 41, 46, 47, 48, 51, 54, 55, 57, 61, 62, 65], "p": [6, 8, 9, 12, 51, 52, 59, 61], "re": [6, 12, 18, 32, 48, 50, 51, 59, 61], "right": [6, 10, 11], "18": [6, 12, 55], "functool": [6, 12], "qubit_num": [6, 8, 14], "num": 6, "psi_stat": 6, "phi_stat": 6, "ham": [6, 8], "ham_matrix": 6, "exp_val": [6, 7, 13, 14, 36, 46], "dot": [6, 10, 12], "conj": 6, "707107": 6, "7071067690849304": 6, "19": [6, 12, 35, 55], "u_psi": 6, "u_phi": 6, "ham_cir": 6, "100000": [6, 50], "mean_val": 6, "qc": [6, 34], "85356": 6, "14644": 6, "70712": 6, "0015811092713661505": 6, "20": [6, 12, 24, 30, 54, 55, 59, 63, 65], "mqpu": [6, 33, 37, 41, 46, 50], "qpu_count": [6, 36], "14": [6, 12, 35, 47, 55, 63], "i_result": 6, "63807": 6, "36193": 6, "27614": 6, "0021491238917289066": 6, "49929": 6, "50071": 6, "00142": 6, "0022360657230949183": 6, "50041": 6, "49959": 6, "00082": 6, "0022360672257336093": 6, "50276": 6, "49724": 6, "00552": 6, "0022360339102974265": 6, "21": [6, 12, 55], "my_mat": 6, "dtype": [6, 9, 12, 51], "k": [6, 8, 11, 22, 54], "linalg": [6, 12], "eigh": 6, "eigen": [6, 21, 58], "00551752": 6, "27614248": 6, "00303004": 6, "99999541": 6, "highlight": 7, "pytorch": 7, "layer": [7, 10, 22, 52, 54], "acceler": [7, 15, 16, 35, 37, 41, 43, 44, 50, 58, 59, 61, 65, 67], "maximis": 7, "classif": 7, "mnist": 7, "dataset": 7, "classifi": 7, "hand": [7, 35, 36, 37, 61], "written": [7, 12, 18, 53, 54, 59, 63], "digit": 7, "torch": 7, "torchvis": 7, "17": [7, 12, 55, 63], "scikit": 7, "learn": [7, 10, 16, 35, 40, 41, 53, 65, 67], "autograd": 7, "nn": 7, "sklearn": 7, "model_select": 7, "train_test_split": 7, "manual_se": 7, "22": [7, 12, 41, 55, 59, 61], "44": [7, 12], "qpp": [7, 8, 10, 11, 14, 33, 35, 37, 41, 50, 55, 58, 61, 65], "prepare_data": 7, "target_digit": 7, "sample_count": [7, 50], "test_siz": 7, "load": [7, 18, 23, 34, 35, 47, 55, 57], "imag": [7, 10, 16, 47, 59, 65, 67], "percentag": 7, "test": [7, 12, 15, 20, 50, 59, 61], "remaind": [7, 10], "train": 7, "totensor": 7, "normal": [7, 13, 14, 53], "1307": 7, "3081": 7, "download": [7, 59, 61, 65], "filter": 7, "label": [7, 12, 55, 59, 65], "datapoint": 7, "subset_indic": 7, "randperm": 7, "unsqueez": 7, "relabel": 7, "min": [7, 47], "x_train": 7, "x_test": 7, "y_train": 7, "y_test": 7, "100": [7, 9, 12, 14, 21, 44], "shuffl": 7, "random_st": 7, "42": [7, 12, 13, 14], "30": [7, 12, 36, 43, 50], "classification_threshold": 7, "boundari": 7, "accuraci": [7, 37], "parmet": 7, "shift": [7, 35, 61], "magnitud": 7, "visualis": 7, "sample_to_plot": 7, "grid_img": 7, "util": [7, 9, 18, 30, 35, 36, 37, 50, 55, 58], "make_grid": 7, "pad": 7, "imshow": 7, "permut": 7, "show": [7, 8, 10, 11, 12, 13, 14, 36, 46, 47, 51, 59, 61], "quantumfunct": 7, "finit": 7, "theta_v": 7, "excetut": 7, "live": 7, "tolist": 7, "shape": [7, 14, 50], "staticmethod": 7, "quantum_circuit": 7, "backward": [7, 24], "reshap": 7, "save_for_backward": 7, "grad_output": 7, "saved_tensor": 7, "thetas_plu": 7, "exp_vals_plu": 7, "thetas_minu": 7, "exp_vals_minu": 7, "mul": 7, "quantumlay": 7, "adher": [7, 22, 24, 30, 53, 58], "super": 7, "hybrid_qnn": 7, "fc1": 7, "28": [7, 12, 14, 16, 36, 44, 59, 61, 65, 67], "256": 7, "fc2": 7, "128": [7, 55], "dropout": 7, "25": [7, 11, 12, 21, 35, 36, 37, 41, 50, 61], "fc3": 7, "64": [7, 36, 37, 55, 59, 61], "fc4": 7, "32": [7, 12, 34, 37, 55, 61], "fc5": 7, "feed": [7, 10], "view": [7, 23, 61, 66], "relu": 7, "fed": 7, "sigmoid": 7, "accuracy_scor": 7, "y_hat": 7, "hybrid_model": 7, "adadelta": 7, "lr": [7, 55], "001": [7, 11, 12, 61], "weight_decai": 7, "loss_funct": 7, "bceloss": 7, "training_cost": 7, "testing_cost": 7, "training_accuraci": 7, "testing_accuraci": 7, "zero_grad": 7, "y_hat_train": 7, "train_cost": 7, "eval": 7, "no_grad": 7, "y_hat_test": 7, "test_cost": 7, "12": [7, 12, 18, 35, 55, 59, 61, 63], "figsiz": [7, 12], "subplot": [7, 12], "cost": [7, 8, 10, 13, 14, 15, 18, 35, 54], "legend": 7, "tight_layout": 7, "13": [7, 8, 10, 12, 13, 14, 50, 52, 54, 55, 61], "__version__": [7, 10, 11], "latest": [7, 10, 11, 16, 36, 59, 61, 67], "http": [7, 10, 11, 34, 36, 47, 59, 61], "github": [7, 10, 11, 16, 34, 37, 59, 61, 65, 67], "com": [7, 10, 11, 34, 47, 59, 61], "a726804916fd397408cbf595ce6fe5f33dcd8b4c": [7, 10, 11], "cliqu": 8, "graph": [8, 10, 52], "paper": [8, 52], "big": 8, "node": [8, 10, 17, 36, 50, 59], "edg": [8, 10], "non_edg": 8, "weight": 8, "6686": 8, "1453": 8, "penalti": 8, "num_lay": 8, "expens": 8, "6886": 8, "1091": 8, "0770": 8, "ham_cliqu": 8, "spin_ham": [8, 14], "wt": 8, "zip": [8, 59], "term_coeffici": 8, "term_word": 8, "dc_qaoa": 8, "coef": 8, "pauli_word": [8, 36], "exp_pauli": 8, "iiziiz": 8, "ziizii": 8, "1657": 8, "iziiii": 8, "iziizi": 8, "42735": 8, "iiizii": 8, "2791499999999996": 8, "iiiiii": 8, "iiziii": 8, "iiiiiz": 8, "ziiiii": 8, "iiiizi": 8, "66": 8, "21810696323572243": [8, 10], "20613464375211488": [8, 10], "2546877639814583": [8, 10], "3657985647468064": [8, 10], "37118004688049144": 8, "03656087558321203": 8, "08564174998504231": 8, "21639801853794682": 8, "11122286088634259": 8, "1743727097033635": 8, "36518146001762486": 8, "15829741539542244": 8, "3467434780387345": 8, "28043500852894776": 8, "09986021299050934": 8, "14125225086023052": 8, "19141728018199775": 8, "11970943368650361": 8, "3853063093646483": 8, "1112643868789806": 8, "3527177454825464": 8, "22156160012057186": 8, "1418496891385843": 8, "32811766468303116": 8, "367642000671186": 8, "34158180583996006": 8, "10196745745501312": 8, "29359239180502594": 8, "3858537615546677": 8, "19366130907065582": 8, "24570488114056754": 8, "3332307385378807": 8, "12287973244618389": 8, "007274514934614895": 8, "015799547372526146": 8, "3578070967202224": 8, "39268963055535144": 8, "19872246354138554": 8, "16668715544467982": 8, "13777293592446055": 8, "17514665212709513": 8, "15350249947988204": 8, "32872977428061945": 8, "20068831419712105": 8, "032919322131134854": 8, "19399909325771983": 8, "09477141125241506": 8, "08210460401106645": 8, "21392577760158515": 8, "3393568044538389": 8, "14615087942938465": 8, "03790339186006314": 8, "2843250892879255": 8, "3151384847055956": 8, "19983741137121905": 8, "27348611567665115": 8, "33457528180906904": 8, "14145414847455462": 8, "20604220093940323": 8, "05410235084309195": 8, "04447870918600966": 8, "3355714098595045": 8, "266806440171265": 8, "07436189654442632": 8, "2789176729721685": 8, "2427508182662484": 8, "optimal_expect": [8, 10, 52], "optimal_paramet": [8, 10, 35, 52], "0057970170760537": 8, "0617900450255213": 8, "008832997414504553": 8, "5446745231437978": 8, "9170743966952536": 8, "5684145055308018": 8, "45653992738579674": 8, "48765328828009236": 8, "08690545932812363": 8, "4396413285058074": 8, "18459993158979182": 8, "309747594917737": 8, "2588385005776594": 8, "834255663515425": 8, "674712608431175": 8, "40174553656823186": 8, "1936475123928361": 8, "11292461472367524": 8, "40520422214477836": 8, "5249647407525035": 8, "8276837818165452": 8, "2945660883282474": 8, "8060498989662159": 8, "08051672267342141": 8, "016438756265571293": 8, "5245041151262497": 8, "4087477995498743": 8, "24688680789607903": 8, "1121838066265077": 8, "1445970943333728": 8, "22281558391261153": 8, "29034932090910637": 8, "0492037973620043": 8, "2734013684834806": 8, "5265417924961102": 8, "5099056677967553": 8, "8636684922225737": 8, "6164906874232119": 8, "42851259141848624": 8, "09675272347583658": 8, "05697275350531247": 8, "7102412317670379": 8, "11174687408874051": 8, "32505750242276577": 8, "4397450017834574": 8, "023604090020531092": 8, "072436348972407": 8, "38357054930488194": 8, "13613334013073858": 8, "10505045798768743": 8, "0359359294549595": 8, "24377425227508304": 8, "10609870738840588": 8, "2073332743736556": 8, "07232539343493427": 8, "6190529241716675": 8, "03799182564866846": 8, "17548654124993912": 8, "5257077568577536": 8, "23376653076971432": 8, "3391308272563698": 8, "4193139961661264": 8, "02390444901420668": 8, "2521154835623746": 8, "1843328649807838": 8, "6609672889772077": 8, "2612231428844001": 8, "200000": 8, "mvwcp": 8, "partit": [8, 10, 35, 36, 61], "altern": [8, 10, 34, 44, 47, 49, 52, 54, 59, 61, 65], "111000": 8, "character": [9, 12], "coher": [9, 22], "incoher": 9, "sourc": [9, 10, 12, 16, 32, 37, 43, 51, 55, 58, 61, 62, 65, 67], "aris": 9, "commonli": 9, "systemat": 9, "origin": [9, 32, 43, 54, 55], "miscalibr": 9, "epsilon": 9, "entangl": [9, 23, 35, 39, 47, 53, 54], "lead": [9, 10], "mix": [9, 47, 51], "pure": [9, 21, 22, 29, 54], "emploi": 9, "formal": 9, "complet": [9, 18, 34, 59, 61, 65], "posit": [9, 10, 12, 25, 37], "preserv": 9, "k_i": 9, "satisfi": [9, 30, 47, 59], "sum_": [9, 10, 11, 26, 53], "mathbb": [9, 10, 53], "pmatrix": 9, "To": [9, 10, 11, 12, 18, 22, 25, 30, 34, 35, 36, 37, 40, 41, 44, 46, 47, 48, 51, 55, 57, 58, 59, 61, 62, 63, 65], "ideal": [9, 35, 47], "noiseless": 9, "ideal_count": 9, "choos": [9, 41, 61], "error_prob": 9, "kraus_0": [9, 51], "complex128": [9, 51], "kraus_1": [9, 51], "bitflip_channel": 9, "0th": 9, "bitflip": [9, 12], "impact": [9, 51], "longer": [9, 44, 59], "uniformli": 9, "noisy_count": [9, 51], "850": 9, "88": 9, "56": 9, "noisy_result": [9, 51], "8666666666666666": 9, "farhi": 10, "et": 10, "al": 10, "introduc": [10, 18], "problem": [10, 11, 13, 32, 40, 52], "dive": [10, 53, 61], "ll": [10, 11, 48, 54, 55, 58, 62], "maxim": [10, 35, 37, 39, 47, 50], "although": [10, 53], "rel": [10, 37], "easi": [10, 51, 63], "few": 10, "vertic": [10, 53], "hard": 10, "wide": [10, 32, 55], "machin": [10, 17, 31, 34, 36, 47, 61], "design": [10, 15, 17, 65], "statist": [10, 18, 21, 41, 53], "among": [10, 36], "furthermor": [10, 16, 67], "present": [10, 12, 41, 44, 59, 62], "tutori": [10, 12, 61], "wider": [10, 36], "portfolio": 10, "shop": 10, "schedul": [10, 41], "vertex": 10, "subseteq": 10, "interchang": [10, 37], "undirect": 10, "v_0": 10, "v_1": 10, "exactli": 10, "bigcup": 10, "bigcap": 10, "emptyset": 10, "illustr": [10, 18, 34, 36, 45, 47, 48, 51, 52], "line": [10, 34, 36, 37, 43, 47, 53, 55, 58, 59, 61], "disjoint": 10, "easili": [10, 41, 43, 44, 54, 59, 61], "visual": [10, 32], "color": 10, "green": 10, "grai": 10, "depict": [10, 53], "distinct": [10, 32, 53], "substack": 10, "sometim": 10, "01100": [10, 36], "01011": 10, "v1": [10, 34, 52], "v2": [10, 52], "v0": [10, 52], "v3": [10, 52, 59, 61], "v4": [10, 61], "solut": 10, "10100": 10, "01010": 10, "10101": 10, "edges_src": 10, "edges_tgt": 10, "algortihm": 10, "particular": [10, 34, 53, 59, 61], "hamilitonian": 10, "distinguish": [10, 32], "associ": [10, 23, 36, 53], "block": [10, 27, 54], "better": [10, 12, 35, 37, 59], "mixer": [10, 52], "deeper": [10, 53], "layer_count": [10, 52], "qaoaproblem": 10, "alpha": [10, 53], "subcircuit": [10, 40], "rz": [10, 21, 25, 52], "kernel_qaoa": [10, 52], "restrict": [10, 36], "plaehold": 10, "place": [10, 36, 39, 41, 43, 51], "compon": [10, 59, 61, 65], "qubitu": 10, "qubitv": 10, "mention": 10, "earlier": [10, 41, 63], "z_v": 10, "vale": 10, "notic": [10, 32, 43, 44, 50, 55, 62], "arbirtrari": 10, "formula": 10, "z_uz_v": 10, "minimum": [10, 13, 35], "refram": 10, "promot": [10, 15, 65], "equat": [10, 11], "replac": [10, 34, 35, 54, 55, 57, 59, 61], "reformul": 10, "hamiltonian_max_cut": 10, "inititi": 10, "routin": [10, 18, 54], "param": [10, 21, 22, 25, 35, 50, 52, 54], "comment": [10, 43], "uncom": [10, 59, 61], "least": [10, 36], "iiziz": 10, "izzii": 10, "iiiii": 10, "zziii": 10, "iiizz": 10, "iizzi": 10, "ziizi": 10, "495973826282007": 10, "51349181993727": 10, "21299416361632417": 10, "3250526425808945": 10, "886630847343767": 10, "outcom": 10, "max_cut": 10, "11111": 10, "11110": 10, "01101": 10, "148": 10, "01110": 10, "47": [10, 12], "01000": 10, "00110": 10, "54": [10, 12], "165": 10, "00101": 10, "154": 10, "00100": 10, "01001": 10, "41": 10, "00000": 10, "00011": 10, "10011": [10, 36], "00010": 10, "01111": 10, "11011": 10, "00111": 10, "11100": 10, "10001": 10, "65": [10, 12], "10010": 10, "144": [10, 12], "10110": 10, "40": [10, 12, 13, 50], "10000": [10, 34, 41, 47, 50], "10111": 10, "11000": 10, "11101": 10, "11001": 10, "11010": 10, "aid": [11, 17], "mani": [11, 25, 28, 36, 37, 41, 50, 65], "area": [11, 36], "signal": [11, 23], "compress": 11, "quantiz": 11, "qft": 11, "ingredi": 11, "shor": 11, "exponenti": [11, 12, 26, 50], "faster": [11, 37], "factor": [11, 12], "prime": 11, "plai": 11, "vital": 11, "role": 11, "interest": [11, 13, 14, 46, 48], "idea": 11, "frequenc": 11, "domain": 11, "easier": [11, 18, 55, 58], "analogi": 11, "ixi": 11, "101": [11, 12, 21], "rangl": [11, 12, 18, 65], "summar": [11, 61], "hadamard": [11, 15, 20, 25, 30, 32, 43, 48, 51, 53, 57], "extend": [11, 15, 17, 53, 64], "5i": 11, "010": [11, 12], "35": [11, 12, 14], "0i": 11, "25i": 11, "35i": 11, "r_k": 11, "bmatrix": [11, 12, 53], "ciruit": 11, "quantum_fourier_transform": 11, "input_st": [11, 34, 47], "cr1": [11, 21], "mgpu": [11, 33, 35, 36, 37, 50], "multi": [11, 15, 16, 17, 20, 23, 25, 29, 33, 34, 35, 41, 45, 46, 53, 58, 59, 65, 67], "hardwar": [11, 15, 16, 33, 37, 41, 45, 67], "zeroth": 11, "decim": 11, "round": [11, 21, 54], "r1": [11, 21, 25, 32], "571": 11, "7854": 11, "25j": 11, "35j": 11, "verifi": [11, 53], "continu": [11, 41, 47, 55], "seri": [11, 34, 47], "henc": [11, 32, 36, 41, 50, 53, 59, 61], "best": [11, 59, 61], "fast": [11, 23, 37, 40], "n2": 11, "why": 11, "life": [11, 35], "li": [11, 55], "One": [11, 18, 32, 36, 37, 42, 46], "invert": 11, "revers": [11, 29], "try": [11, 50, 61], "quantum_fourier_transform2": 11, "pai": 11, "attent": 11, "definit": [11, 18, 20, 22, 51, 58], "unitari": [11, 13, 21, 25, 32, 49, 52, 53], "inverse_qft": 11, "approach": [11, 12, 18, 22, 55], "verification_exampl": 11, "caus": [12, 59, 61], "imperfect": 12, "properli": [12, 41, 59], "tool": [12, 16, 32, 55, 57, 59, 63, 67], "understand": [12, 17, 61], "squar": [12, 30, 53], "tell": [12, 53], "independ": [12, 18, 23, 36, 37, 59], "estim": [12, 13, 41], "pseudoinvers": 12, "noisi": [12, 15, 45], "p_": 12, "obtain": [12, 13, 16, 35, 59, 67], "adjust": [12, 37, 59], "quasi": 12, "combin": [12, 15, 40, 41, 53, 64], "correl": 12, "affect": [12, 37, 51, 58], "becom": [12, 37, 46, 61, 62], "impract": 12, "panda": 12, "seaborn": 12, "sn": 12, "pd": 12, "itertool": 12, "union": 12, "set_styl": 12, "dark": 12, "prob": 12, "principl": 12, "yet": [12, 16, 36, 61, 67], "get_nois": 12, "n_qubit": [12, 21, 52, 54], "isinst": 12, "bit_flip": [12, 51], "help": [12, 42, 53, 61], "state_label": 12, "ghz": [12, 35, 39, 41, 44, 47, 48, 50, 55, 62], "ghz_kernel": 12, "plot_cmat": 12, "mat": 12, "fig": 12, "ax": 12, "im2": 12, "matshow": 12, "cmap": 12, "cm": 12, "red": 12, "vmin": 12, "vmax": 12, "set_ytick": 12, "arang": 12, "set_xtick": 12, "set_yticklabel": 12, "set_xticklabel": 12, "set_titl": 12, "r": [12, 25, 30, 34, 35, 36, 37, 46, 47, 54, 55, 61], "fontsiz": 12, "16": [12, 35, 54, 55, 59], "set_xlabel": 12, "xaxi": 12, "set_label_posit": 12, "set_ylabel": 12, "colorbar": 12, "closest": 12, "min_": 12, "rm": [12, 59, 61], "_1": 12, "Then": [12, 43, 47, 51, 57, 58], "find_closest_distribut": 12, "empirical_dist": 12, "empir": 12, "l1": 12, "ord": 12, "constraint": [12, 22, 23, 24, 37, 41, 47, 53], "con": 12, "ineq": 12, "fun": [12, 14], "eq": [12, 55], "bnd": 12, "initial_valu": 12, "slsqp": 12, "maxit": [12, 13, 14], "get_counts_from_distribut": 12, "dist": 12, "drawn": 12, "choic": [12, 37], "return_count": 12, "1024": [12, 44], "join": [12, 43], "noise_1": 12, "ghz_result": 12, "noisy_dict_1": 12, "dict": 12, "noisy_res_1": 12, "352": 12, "43": 12, "367": 12, "011": [12, 21], "61": 12, "110": 12, "53": 12, "low": [12, 25, 50], "noise_2": 12, "noisy_dict_2": 12, "noisy_res_2": 12, "149816047538945": 12, "3802857225639665": 12, "292797576724562": 12, "212": 12, "122": 12, "189": 12, "87": 12, "78": 12, "131": 12, "94": 12, "a_1": 12, "otim": 12, "single_qubit_label": 12, "single_qubit_st": 12, "924": 12, "104": 12, "920": 12, "true_stat": 12, "observed_st": 12, "90234375": 12, "1015625": 12, "09765625": 12, "8984375": 12, "kron": 12, "joint": [12, 47], "a_pinv": 12, "pinv": 12, "positive_dist": 12, "ncorrect": [12, 21], "neg": [12, 25, 37], "476": 12, "501": [12, 18], "15": [12, 50, 54, 55, 59, 61], "datafram": 12, "mitigated_sg": 12, "kind": [12, 41], "bar_label": 12, "assumpt": 12, "small": [12, 37], "special": [12, 22, 27, 55], "a_n": 12, "local_label": 12, "local_st": 12, "388": 12, "235": 12, "174": 12, "79": [12, 35], "58": 12, "23": 12, "38": [12, 59, 61], "370": 12, "60": [12, 61], "107": 12, "224": 12, "162": 12, "marginalized_count": 12, "total_shot": 12, "marginal_ct": 12, "85546875": 12, "15722656": 12, "14453125": 12, "84277344": 12, "6328125": 12, "38476562": 12, "3671875": 12, "61523438": 12, "70800781": 12, "32226562": 12, "29199219": 12, "67773438": 12, "pinv_confusion_matric": 12, "a_joint": 12, "559": 12, "26": [12, 14, 35], "510": [12, 50], "521": 12, "446": 12, "mitigated_k_loc": 12, "accur": 12, "scale": [12, 25, 37, 50, 53], "248": 12, "159": 12, "83": 12, "68": 12, "161": 12, "93": 12, "46": 12, "363": 12, "253": 12, "76": 12, "234": 12, "378": 12, "27": [12, 41], "150": [12, 53], "36": [12, 50, 54], "74": 12, "106": 12, "145": 12, "251": 12, "386": 12, "34": 12, "99": 12, "29": [12, 36], "229": 12, "247": 12, "70": 12, "163": 12, "371": 12, "95": 12, "77": 12, "157": 12, "233": 12, "85": [12, 50], "396": 12, "31": [12, 35, 50], "393": 12, "160": 12, "a_ful": 12, "24": [12, 58, 62], "distanc": [12, 13], "09734490298929": 12, "714": 12, "211": 12, "152": 12, "49": 12, "63": 12, "422": 12, "683": 12, "302": 12, "mitigated_ful": 12, "molecular": [13, 15], "preprocess": 13, "h_2": 13, "molecul": [13, 15], "hartre": 13, "fock": 13, "uccsd": 13, "openfermionpyscf": [13, 14], "chain": [13, 32], "hydrogen": [13, 54], "atom": [13, 14, 53, 54], "seper": 13, "along": [13, 18, 34, 35, 37, 41], "fix": [13, 37], "interv": 13, "bond": 13, "interatom": 13, "electrostat": 13, "forc": [13, 36, 53], "electron": [13, 14], "proton": 13, "shield": 13, "neutron": 13, "chemic": 13, "minimis": 13, "stabl": [13, 61], "hydrogen_count": 13, "angstrom": 13, "bond_dist": 13, "7474": 13, "geometri": [13, 14], "chemistri": 13, "create_molecular_hamiltonian": 13, "sto": 13, "3g": 13, "electron_count": [13, 14], "n_electron": 13, "n_orbit": 13, "coupl": [13, 23, 37, 47, 61], "cluster": [13, 36, 37], "uccsd_num_paramet": [13, 14], "builtin": [13, 55], "1371744305855906": 13, "popular": [13, 61], "callback": [13, 14], "xk": [13, 14], "x0": [13, 14, 18], "titl": [13, 14, 34, 54, 61, 65], "pyscf": 14, "openfermion": 14, "gto": 14, "scf": 14, "mcscf": 14, "cc": [14, 32, 55, 59], "1173": 14, "4691": 14, "7570": 14, "mol": 14, "charg": 14, "631g": 14, "myhf": 14, "rhf": 14, "max_cycl": 14, "nelec": 14, "nelectron": 14, "norb": 14, "mo_coeff": 14, "orbit": 14, "norb_ca": 14, "nele_ca": 14, "mycasci": 14, "casci": 14, "ncore": 14, "occupi": [14, 36], "frozen": 14, "mycc": 14, "e_tot": 14, "converg": 14, "9839755372789": 14, "98508980454675": 14, "e_corr": 14, "001114267267875617": 14, "jordan_wign": 14, "get_fermion_oper": 14, "timeit": [14, 41, 50], "run_pyscf": 14, "moleculardata": 14, "molecular_hamiltonian": 14, "get_molecular_hamiltonian": 14, "occupied_indic": 14, "active_indic": 14, "fermion_hamiltonian": 14, "qubit_hamiltonian": 14, "electron_num": 14, "start_tim": 14, "default_tim": 14, "300": 14, "end_tim": 14, "elaps": 14, "warn": [14, 34], "pleas": [14, 16, 35, 36, 37, 47, 50, 57, 59, 61, 65, 67], "tmp": [14, 59], "ipykernel_23147": 14, "4290935201": 14, "py": [14, 36, 37, 41, 42, 50, 54, 61, 65], "complexwarn": 14, "cast": 14, "discard": [14, 18], "98415928173183": 14, "105": 14, "929891359000067": 14, "welcom": [15, 35, 48, 61], "page": [15, 41, 46, 48, 59, 61, 65], "streamlin": [15, 65], "develop": [15, 22, 23, 34, 35, 37, 45, 53, 57, 58, 59, 62, 65], "scalabl": [15, 35, 65], "offer": [15, 35, 65], "unifi": [15, 33, 65], "brows": 15, "amd64": [15, 16, 67], "pr": 15, "2023": 15, "releas": [15, 33, 36, 37, 55, 61, 65, 67], "toolchain": [15, 31, 34, 41, 55, 61, 62, 64, 65], "heterogen": [15, 17, 40, 59], "your": [15, 18, 34, 35, 36, 37, 38, 43, 46, 47, 50, 51, 54, 58, 59, 61], "troubleshoot": [15, 38], "introduct": [15, 31, 45, 63, 65], "synthesi": [15, 17, 20, 26, 30, 31, 45, 55], "bernstein": [15, 45, 61], "vazirani": [15, 45, 61], "eigensolv": [15, 45], "cuquantum": [15, 37, 45, 50, 58, 59], "deutsch": 15, "fourier": [15, 21], "cut": [15, 52], "qaoa": [15, 52], "neural": 15, "network": [15, 16, 34, 35, 44, 47, 58, 61, 67], "dock": 15, "dc": 15, "readout": 15, "mitig": 15, "water": 15, "space": [15, 23, 30, 36, 47], "cloud": [15, 16, 33, 34, 47, 67], "processor": [15, 16, 18, 23, 33, 41, 61, 65, 67], "center": [15, 60, 61], "integr": [15, 17, 23, 30, 34, 36, 61, 62], "downstream": [15, 58, 62, 64], "cmake": [15, 57, 58, 64], "ir": [15, 20, 42, 56, 57, 58], "api": [15, 18, 20, 24, 25, 28, 30, 34, 35, 36, 37, 41, 48, 58, 61], "main": [16, 18, 21, 32, 35, 41, 43, 44, 46, 47, 48, 49, 51, 52, 54, 55, 59, 61, 65, 67], "branch": [16, 20, 59, 61, 67], "repositori": [16, 57, 58, 59, 61, 67], "docker": [16, 59, 65, 67], "nightli": [16, 61, 67], "found": [16, 18, 21, 25, 34, 41, 58, 59, 61, 63, 64, 65, 67], "power": [16, 35, 37, 50, 53, 67], "With": [16, 36, 41, 51, 55, 62, 67], "greatli": [16, 67], "increas": [16, 37, 41, 50, 61, 65, 67], "frontend": [16, 67], "blog": [16, 67], "setup": [16, 37, 47, 61, 67], "benefit": [16, 41, 65, 67], "wheel": [16, 36, 37, 59, 67], "improv": [16, 37, 50, 61, 67], "variou": [16, 36, 39, 48, 51, 55, 58, 67], "hpc": [16, 61, 67], "scenario": [16, 49, 61, 67], "ve": [16, 48, 63, 67], "workload": [16, 36, 61, 67], "gnu": [16, 55, 59, 61, 67], "guid": [16, 34, 59, 61, 63, 65, 67], "older": [16, 61, 67], "glibc": [16, 67], "oqc": [16, 33, 67], "iqm": [16, 33, 67], "publish": [16, 61, 67], "experiment": [16, 61, 67], "look": [16, 32, 34, 36, 40, 41, 44, 46, 47, 48, 49, 50, 51, 54, 55, 59, 61, 67], "arm": [16, 59, 61, 65, 67], "aarch64": [16, 65, 67], "pypi": [16, 59, 65, 67], "quantinuum": [16, 33, 67], "ionq": [16, 33, 67], "linux": [16, 55, 59, 61, 67], "concept": [17, 18, 22, 24], "bind": [17, 20, 22, 25], "coprocess": 17, "annot": [17, 22, 39, 48], "aspect": [17, 18, 37], "core": [17, 18, 37, 50, 55], "higher": 17, "displai": 17, "namespac": [17, 18, 20, 21, 22, 25, 26, 28, 30, 31, 35, 36, 41, 46, 52, 57, 58], "philosophi": 18, "stand": 18, "alon": 18, "adaptor": 18, "post": [18, 34, 61], "returntyp": 18, "hasvoidreturntyp": 18, "is_void_v": 18, "sample_opt": 18, "bell": 18, "bel": 18, "printf": [18, 21, 30, 36, 44, 46, 48, 49, 52, 54, 59], "lu": [18, 21, 30, 44, 48, 49], "sequential_data": 18, "implicit": [18, 30, 32], "reg1": 18, "499": 18, "content": [18, 34, 47, 54, 58, 61], "appear": [18, 61], "b": [18, 47], "similar": [18, 41, 59], "alwai": [18, 37, 61], "middl": 18, "subsequ": [18, 23, 26, 28, 59, 61], "implicitli": [18, 23, 32], "ancilla": [18, 20], "difficult": 18, "discern": 18, "ones": 18, "recommend": [18, 59, 61, 65], "silent": 18, "ancillari": [18, 43], "varieti": [18, 41], "There": [18, 20, 34, 35, 36, 50, 61, 63], "enforc": 18, "sample_async_result": 18, "async_sample_result": [18, 36], "langl": 18, "\ud835\udeb9": 18, "quickli": [18, 61], "observe_opt": 18, "instanti": [18, 23, 29, 30, 35, 36, 52], "retain": [18, 24], "measurecount": 18, "spinop": 18, "x0x1exp": 18, "x0x1data": 18, "qarrai": [18, 21, 22, 29, 48, 55], "907": [18, 21, 26, 35, 36, 46, 54], "1433": [18, 21, 26, 35, 36, 46, 54], "21829": [18, 21, 26, 35, 36, 46, 54], "125": [18, 21, 26, 35, 36, 46, 54], "lf": [18, 21, 36, 46], "analyt": 18, "stochast": 18, "async_observe_result": 18, "broader": [18, 36], "often": [18, 32, 59, 61], "extrem": 18, "dictat": 18, "safe": 18, "moreov": [18, 23, 36, 40, 58], "providesgradi": 18, "_providesgradi": 18, "someth": [18, 30], "max_ev": [18, 54], "200": 18, "opt_energi": 18, "grad_vec": 18, "\ud835\udeb9_i": 18, "potenti": [18, 41], "variad": 18, "address": [18, 36, 59], "issu": [18, 37, 59, 61], "overal": [18, 55, 58], "deuteron_n3_ansatz": 18, "x1": 18, "vctrl": 18, "h3": 18, "625": 18, "913119": 18, "make_tupl": 18, "l": [18, 55, 63], "bfg": 18, "min_val": 18, "permit": 19, "facilit": [20, 61], "privat": [20, 30], "thenfunctor": 20, "predefin": 20, "otherkernelbuild": 20, "kerneltocal": 20, "kerneltocontrol": 20, "kerneltoadjoint": 20, "argsarrai": 20, "decltyp": 20, "tuple_s": 20, "integral_const": 20, "sizeof": 20, "tuple_el": 20, "conditional_t": [20, 30], "factori": 20, "xprep": 20, "qubitin": 20, "hadamardtest": 20, "num_it": 21, "c_str": 21, "phase_estim": 21, "cpp": [21, 34, 35, 36, 37, 41, 44, 46, 47, 48, 49, 51, 54, 55, 57, 58, 59, 61, 62, 63, 65], "qpe": 21, "stdio": [21, 59], "cmath": 21, "iqft": 21, "denom": 21, "1ul": 21, "eigenst": 21, "evolut": [21, 23, 32, 53, 58], "stateprep": [21, 22], "ncountingqubit": 21, "state_prep": 21, "oracl": [21, 43], "counting_qubit": 21, "state_regist": 21, "put": [21, 30, 51, 53], "r1pigat": 21, "mostprob": 21, "to_integ": 21, "piestim": 21, "tgate": 21, "xgate": [21, 51], "nc": 21, "nq": 21, "countingqubit": 21, "stateregist": 21, "deuteron_n2_ansatz": 21, "param_spac": 21, "linspac": [21, 47], "energy_at_param": 21, "energyatparam": 21, "reflect_about_uniform": 21, "ctrlqubit": 21, "lastqubit": 21, "compute_act": [21, 27], "run_grov": 21, "callablekernel": 21, "n_iter": 21, "target_st": 21, "target_bit_set": 21, "secret": [21, 61], "strtol": 21, "null": [21, 61], "0b1011": 21, "compute_oracl": 21, "reflect": [21, 37], "iterative_qp": 21, "iqp": 21, "cr0": 21, "cr2": 21, "m_pi_4": 21, "differenti": 22, "former": 22, "latter": [22, 55], "my_first_entry_point_kernel": 22, "my_second_entry_point_kernel": 22, "my_first_pure_device_kernel": 22, "bodi": 22, "parent": 22, "stack": 22, "boolexprfromqubitmeasur": 22, "another_qubit": 22, "uncomput": [22, 23], "is_arithmetic_v": 22, "span": [22, 30], "recurs": 22, "mycustomsimplestruct": 22, "recursivevec": 22, "var": [22, 65], "kernelthatreturn": 22, "mysimplestruct": 22, "recursivelist": 22, "fill": [22, 47, 58], "Not": [22, 35, 61], "1415926": 22, "still": [22, 32, 41, 47, 51, 53, 61], "kernellambda": 22, "synchron": [22, 47], "mystateprep": 22, "prep": 22, "mygenericalgorithm": 22, "placehold": 22, "mygenericalgorithm2": 22, "callkernel": 22, "anothervers": 22, "constrain": [22, 49], "is_convertible_v": 22, "takes_qubit": [22, 49], "mygenericalgorithmonqarrai": 22, "mygenericalgorithmonqubit": 22, "presum": 23, "graphic": 23, "fpga": 23, "evolv": [23, 53], "concurr": [23, 35], "messag": [23, 35, 59, 61], "inter": [23, 37], "fabric": [23, 54], "drive": 23, "infinit": [23, 30, 41], "hidden": [23, 43], "purpos": [23, 32, 61], "novel": 23, "placement": 23, "copyabl": [23, 30], "flavor": 23, "tightli": 23, "modal": 23, "influenc": 23, "previou": [24, 30, 54, 61], "sfina": 24, "foundat": 25, "operand": 25, "inst_nam": 25, "header": [25, 59, 61], "synthes": [25, 29, 55], "reli": [25, 55, 61], "tdg": 25, "qubitarg": 25, "qr": [25, 37], "scalarangl": 25, "rotation_nam": 25, "measure_op": 25, "cnot": [25, 39, 53], "convei": 25, "offici": [25, 59, 61], "p_i": 26, "prod_": 26, "sigma_j": 26, "complic": 26, "th": 26, "trotter": 26, "w": [27, 37, 47], "intent": 27, "u_cod": 27, "v_code": 27, "computef": 27, "actionf": 27, "computel": 27, "segment": [27, 65], "effort": 28, "desir": [28, 36, 41, 58, 59, 61], "get_platform": [28, 36, 46], "ctrl_qubit": 29, "quantumregist": 29, "x_gate": 29, "toffoli": 29, "ctrl_bit": 29, "rx_and_h_gat": 29, "kerneltestcontrol": 29, "kerneltestadjoint": 29, "aggreg": 29, "qubit0": [29, 37], "qubit1": [29, 37], "kernel_arg": 29, "fundament": [30, 53, 61, 65], "dimension": [30, 53], "hilbert": 30, "absolut": [30, 55], "theorem": 30, "movabl": 30, "never": 30, "n_level": 30, "discret": 30, "adl": 30, "deal": 30, "group": [30, 37], "familiar": 30, "done": [30, 42, 51, 59, 61], "inner": [30, 36, 43], "stride": 30, "first_5": 30, "qb": 30, "knowledg": 30, "ahead": 30, "storag": [30, 53], "fivecompiletimequbit": 30, "motiv": [31, 59], "formul": 32, "short": 32, "particl": 32, "conceptu": 32, "effect": [32, 37, 41, 50, 51, 53, 65], "sai": 32, "embodi": 32, "greater": [32, 35, 37, 53], "behind": 32, "dataflow": 32, "contrast": 32, "side": [32, 61], "consum": 32, "truli": 32, "ssa": 32, "clarifi": 32, "toi": 32, "foo": 32, "boilerpl": [32, 58], "c0": 32, "c1": 32, "extract_ref": [32, 55], "ref": [32, 55], "bunch": 32, "decid": 32, "i1": [32, 55], "imagin": 32, "adjac": [32, 34], "naiv": 32, "awai": 32, "Such": [32, 41], "miss": [32, 37, 59], "Of": 32, "cours": 32, "correctli": [32, 59, 63], "quit": [32, 41], "prone": 32, "analys": 32, "reason": 32, "q0_1": 32, "q0_0": 32, "wire": 32, "q0_z": 32, "happen": [32, 61], "elimin": 32, "analysi": [32, 55], "r0": 32, "qref": 32, "unwrap": 32, "misc": 32, "q0_m": 32, "q0_l": 32, "q1_x": 32, "q0_p": 32, "q0_y": 32, "straightforwardli": 32, "cancel": [32, 51, 61, 65], "mmeori": 32, "comprehens": [33, 34], "orca": 33, "tensornet": [33, 35, 36, 37], "mp": [33, 35, 37], "account": [34, 35, 47, 61], "export": [34, 35, 36, 58, 59, 65], "ionq_api_kei": 34, "ionq_generated_api_kei": 34, "src": [34, 59], "authent": [34, 36, 61], "aria": [34, 47], "login": [34, 61], "emit": [34, 55], "diagnost": 34, "inject": [34, 47, 55, 61], "cortex": 34, "cli": [34, 61], "token": [34, 61], "cach": 34, "iqm_tokens_fil": 34, "mandatori": 34, "match": [34, 59, 61], "coco": [34, 47], "adoni": [34, 47], "iqm_server_url": 34, "demo": 34, "fi": [34, 59], "apollo": 34, "url": [34, 36, 47, 59, 61], "oxford": 34, "ring": 34, "topologi": 34, "luci": 34, "kagom": 34, "lattic": 34, "toshiko": 34, "registr": [34, 57, 58], "contact": [34, 47], "oqc_qcaas_support": [34, 47], "oxfordquantumcircuit": [34, 47], "email": [34, 35], "password": [34, 61], "oqc_url": [34, 47], "oqc_email": [34, 47], "oqc_password": [34, 47], "suppli": 34, "qcaa": 34, "servic": [34, 35, 36, 47, 61], "assembli": 34, "qat": 34, "pt": [34, 47, 61], "boson": [34, 47], "photon": [34, 47, 53], "interf": [34, 47], "beam": [34, 47], "splitter": [34, 47], "detector": [34, 47], "bin": [34, 36, 47, 59, 61], "interferomet": [34, 47], "tbi": [34, 47], "delai": [34, 47], "sent": [34, 47], "orca_access_url": [34, 47], "previous": [34, 61], "orca_url": [34, 47], "getenv": [34, 47], "localhost": [34, 36, 47, 61], "bs_angl": [34, 47], "loop_length": [34, 47], "apt": [34, 61], "curl": [34, 59], "jq": 34, "your_alia": 34, "your_password": 34, "qapi": 34, "home": [34, 35, 61], "id_token": 34, "cat": [34, 61], "refresh_token": 34, "refresh": 34, "echo": [34, 35, 59, 61], "quantinuum_config": 34, "cudaq_quantinuum_credenti": 34, "checker": [34, 47], "mere": [34, 59], "h1": [34, 47], "2e": [34, 47], "sc": 34, "1sc": 34, "navig": [34, 61], "tab": [34, 61], "tabl": [34, 35, 36, 58, 61], "world": [35, 40, 48], "research": 35, "visit": [35, 41], "link": [35, 55, 59, 61, 62, 63], "earli": [35, 61], "approv": 35, "nvqc_api_kei": 35, "bash": [35, 59, 61, 65], "session": [35, 36, 61], "bashrc": [35, 61], "rather": [35, 37, 41, 53], "2024": 35, "03": 35, "438": 35, "3600": 35, "exclud": [35, 41, 43, 59], "h100": 35, "80gb": 35, "hbm3": 35, "driver": [35, 59, 61], "gb": [35, 37, 50], "clock": 35, "rate": 35, "mhz": 35, "2619": 35, "1980": 35, "1111111111111111111111111": [35, 50], "486": 35, "0000000000000000000000000": [35, 50], "514": 35, "nvqc_intro": 35, "05": 35, "545": 35, "487": 35, "513": 35, "nvqc_sampl": 35, "grow": [35, 58], "beyond": [35, 37, 50, 57], "ngpu": 35, "encount": [35, 37, 47, 59, 61, 65], "unabl": [35, 61], "deploy": 35, "dm": 35, "ye": [35, 61], "cutensornet": [35, 37], "contract": [35, 37], "wherebi": [35, 36, 37], "pool": [35, 50], "worker": 35, "nqpu": 35, "opt_gradi": 35, "submiss": [35, 42, 47], "energy_futur": 35, "plus_futur": 35, "minus_futur": 35, "optimal_valu": 35, "grad": 35, "paramshift": 35, "74886": 35, "nvqc_vqe": 35, "incom": [35, 49], "attain": 35, "speedup": [35, 50], "On": [35, 36, 37, 44, 48, 61, 65], "busi": 35, "deliv": 35, "substanti": 35, "my": [35, 58, 61], "nvqc_log_level": 35, "disabl": [35, 37, 59], "credenti": [35, 47], "lieu": 35, "api_kei": 35, "nvqc_config": 35, "elucid": 36, "unlik": [36, 41], "opportun": 36, "think": [36, 53], "count_futur": 36, "kerneltobesampl": 36, "runtimeparam": 36, "singleton": [36, 46], "zu": [36, 46], "immedi": [36, 58], "countfutur": 36, "emplace_back": 36, "four": [36, 46, 53], "gpuemulatedqpu": 36, "37": 36, "33": [36, 61], "cudaq_mqpu_ngpu": 36, "suffici": [36, 59, 61, 65], "mpiexec": [36, 37, 59], "python3": [36, 37, 41, 42, 50, 59, 61, 65], "script": [36, 41, 59, 61], "mpirun": [36, 37, 50], "srun": 36, "controls_count": 36, "auto_launch": 36, "isdigit": 36, "nrcontrol": 36, "tidx": 36, "background": 36, "daemon": 36, "qpud": 36, "shut": 36, "down": 36, "manual": [36, 44, 51, 59, 61], "explain": [36, 53], "cudaq_loc": 36, "grep": [36, 59], "qpud_pi": 36, "cuda_visible_devic": [36, 37], "port": [36, 61], "tcp": [36, 61], "ip": 36, "ld_library_path": [36, 59, 65], "launcher": 36, "app": 36, "sure": [36, 59, 61, 63, 65], "firewal": 36, "secur": [36, 61], "port1": 36, "port2": 36, "port3": 36, "port4": 36, "insid": [36, 61], "per": [36, 37, 50, 54], "open": [36, 47, 55, 59, 61], "doc": 36, "flat": 36, "limit": [36, 37, 41, 50, 63], "resolv": 36, "contigu": 36, "byte": [36, 50], "memcpi": 36, "ixiz": 36, "charact": 36, "chosen": [37, 50, 59], "accommod": 37, "switch": [37, 50], "modif": [37, 41, 48], "invalid": 37, "cudaq_fusion_max_qubit": 37, "fusion": 37, "cudaq_fusion_diagonal_gate_max_qubit": 37, "diagon": 37, "cudaq_fusion_num_host_thread": 37, "cudaq_max_cpu_memory_gb": 37, "migrat": [37, 59], "unlimit": 37, "cudaq_max_gpu_memory_gb": 37, "exce": 37, "mpi4pi": [37, 65], "fail": [37, 57, 61], "particularli": [37, 40], "cudaq_mgpu_lib_mpi": 37, "share": [37, 58, 61], "libmpi": [37, 61], "cudaq_mgpu_comm_plugin_typ": 37, "extern": [37, 55, 57], "openmpi": [37, 59, 61, 65], "mpich": [37, 59], "commplugin": 37, "cudaq_mgpu_nqubits_thresh": 37, "threshold": 37, "cudaq_mgpu_fus": 37, "cudaq_mgpu_p2p_device_bit": 37, "gpudirect": 37, "p2p": 37, "cudaq_gpu_fabr": 37, "mnnvl": 37, "nvl": 37, "nvlink": 37, "cudaq_global_index_bit": 37, "comma": 37, "slower": 37, "cudaq_host_device_migration_level": 37, "tune": [37, 54], "fuse": 37, "4x4": 37, "bandwidth": 37, "fewer": 37, "significantli": 37, "suitabl": [37, 59, 61], "thank": 37, "despit": [37, 47], "poor": 37, "exact": 37, "visibl": [37, 61], "cutensornet_comm_lib": 37, "newli": [37, 61], "libcutensornet_distributed_interface_mpi": 37, "dedic": 37, "dgx": 37, "omp_plac": 37, "omp_num_thread": 37, "number_of_cores_per_nod": 37, "number_of_gpus_per_nod": 37, "wave": 37, "sparsiti": 37, "decomposit": 37, "techniqu": [37, 41], "svd": 37, "singular": [37, 59], "truncat": 37, "tractabl": 37, "natur": [37, 53], "footprint": 37, "cudaq_mps_max_bond": 37, "cudaq_mps_abs_cutoff": 37, "cutoff": 37, "largest": 37, "smaller": 37, "trim": 37, "1e": 37, "cudaq_mps_relative_cutoff": 37, "fraction": 37, "cudaq_mps_svd_algo": 37, "gesvd": 37, "gesvdj": 37, "jacobi": 37, "gesvdp": 37, "gesvdr": 37, "medium": 37, "accordingli": 37, "overridden": [37, 58], "cudaq_default_simul": [37, 44], "debug": [38, 55, 59, 61], "amongst": 39, "flexibl": [39, 59], "interpret": [40, 59], "subroutin": 40, "compar": [40, 41, 43, 44, 61, 65], "closer": [40, 48, 55], "collaps": [41, 53, 58], "roughli": [41, 50, 51, 53], "50": [41, 51, 53], "505": 41, "495": 41, "result_0": 41, "ensembl": 41, "5005": 41, "4995": 41, "result_1": 41, "subtl": 41, "repeatedli": 41, "rebuilt": 41, "most_probable_result": 41, "intens": 41, "respons": 41, "event": [41, 59], "finish": [41, 55], "kernel2": 41, "num_gpu": [41, 50], "result_2": 41, "confirm": [41, 47, 51, 59, 61, 65], "determinist": 41, "close": [41, 47], "025": 41, "million": 41, "35x": 41, "sy": [41, 65], "code_to_tim": 41, "1000000": 41, "57462": 41, "stmt": 41, "773286": 41, "isol": 41, "atoi": [41, 65], "chrono": 41, "high_resolution_clock": 41, "durat": 41, "took": 41, "8337": 41, "18988": 41, "cudaq_log_level": 42, "prepend": 42, "cudaq_dump_jit_ir": 42, "output_filenam": 42, "highest": 43, "random_bit": 43, "bitset": 43, "randint": 43, "un": 43, "difficulti": 43, "verif": 43, "hidden_bit": 43, "auxillary_qubit": 43, "auxillari": 43, "bernstein_vazirani": [43, 61], "were": [43, 54, 61], "success": [43, 57], "random_bitstr": 43, "vector_of_bit": 43, "rand": 43, "hidden_bitstr": 43, "recov": 43, "too": [44, 53], "cuquantum_backend": 44, "seem": [44, 53, 61, 65], "hang": [44, 61, 65], "observe_mqpu": 46, "No": [47, 50, 61], "redefin": 47, "flight": 47, "async_count": 47, "txt": [47, 57, 58, 61, 62], "same_fil": 47, "retrieved_async_result": 47, "mimic": 47, "dashboard": 47, "fstream": 47, "meantim": [47, 61], "ofstream": 47, "savem": 47, "readin": 47, "ifstream": 47, "proceed": [47, 59], "qb1": 47, "qb2": 47, "qb3": 47, "qb4": 47, "qb5": 47, "adonis_ghz": 47, "transpar": 47, "worri": 47, "schemat": 47, "optic": 47, "reconfigur": 47, "shifter": 47, "enter": [47, 61], "indistinguish": 47, "vacuum": 47, "interfer": [47, 51, 61], "exit": [47, 50, 61], "half": 47, "n_beam_splitt": 47, "ps_angl": 47, "n_sampl": 47, "helper": [47, 54], "linear_spaced_vector": 47, "static_cast": 47, "sum_loop_length": 47, "accumul": 47, "n_loop": 47, "n_mode": 47, "endpoint": 47, "syntax_check": 47, "sever": [48, 51], "gotten": 48, "veri": [48, 57], "hello": [48, 61], "static_kernel": 48, "x_kernel": 49, "control_vector": 49, "multi_controlled_oper": 49, "ccnot": 49, "applyx": 49, "ccnot_test": 49, "apply_x": 49, "counts2": 49, "seamless": [50, 61], "multithread": 50, "explor": [50, 53, 61], "ghz_state": 50, "sample_ghz_st": 50, "cpu_result": 50, "475": 50, "525": [50, 61], "2500x": 50, "gpu_result": 50, "490": 50, "8700": 50, "freeli": [50, 59, 61], "filenam": 50, "default_rng": 50, "qubits_list": 50, "990": 50, "dev": [50, 59, 61], "xi": 50, "split": 50, "2500": 50, "4x": 50, "asyncresult": 50, "conclud": 51, "examin": 51, "scrambl": 51, "bring": 51, "noise_depolar": 51, "successfulli": 51, "noiseless_count": 51, "environment": 51, "amplitude_damp": 51, "keyword": 51, "noiseless_result": 51, "noise_amplitude_damp": 51, "wherein": 51, "undergo": 51, "degre": 51, "noise_bit_flip": 51, "bf": 51, "phase_flip": 51, "presenc": 51, "noise_phase_flip": 51, "pf": 51, "kraus_oper": 51, "nielsen": 51, "chuang": 51, "chapter": 51, "less": [51, 59], "depol": 51, "99498743710662": 51, "05773502691896258": 51, "unset": 51, "good": [51, 59], "avoid": [51, 59, 65], "rectangular": 52, "n_layer": [52, 54], "hp": 52, "random_vector": [52, 54], "mt19937": [52, 54], "default_se": [52, 54], "16lf": [52, 54], "transmiss": 53, "analog": 53, "counterpart": 53, "transistor": 53, "alter": 53, "superconduct": 53, "materi": 53, "ion": 53, "trap": 53, "concern": [53, 59], "ourselv": 53, "obei": 53, "law": 53, "mathemat": 53, "physicist": 53, "theori": 53, "linearli": 53, "logarithm": 53, "dirac": 53, "beta": [53, 55], "correspondingli": 53, "500": [53, 65], "approx": 53, "feasibl": 53, "art": 53, "manipul": 53, "offload": 53, "equiv": 53, "lvert": 53, "rvert": 53, "502": 53, "498": 53, "modulu": 53, "conserv": 53, "uphold": 53, "excit": 53, "probabilist": 53, "infer": 53, "prior": [53, 59, 61], "wavefunct": 53, "devis": 53, "phenomena": 53, "predict": 53, "postul": 53, "alpha_": 53, "cue": 53, "sens": [53, 55], "mayb": 53, "aforement": 53, "2d": 53, "cartesian": 53, "coordin": 53, "3d": 53, "sphere": 53, "unfortun": 53, "handi": 53, "propos": 54, "simple_vq": 54, "pick": [54, 58], "nminim": 54, "vqe_h2": 54, "builder": [54, 55], "arrang": 54, "so4": 54, "so4_fabr": 54, "block_siz": 54, "counter": 54, "subq": 54, "so4_param": 54, "slice_vector": 54, "odd": 54, "h2_data": 54, "10647701149499994": 54, "0454063328691": 54, "170280101353": 54, "120200490713": 54, "168335986252": 54, "165606823582": 54, "22004130022499996": 54, "174072892497": 54, "17028010135300004": 54, "22004130022499999": 54, "p_counter": 54, "n_blocks_per_lay": 54, "init_param": 54, "max_line_search_tri": 54, "advanc": 54, "much": [54, 58], "slightli": 54, "gradient_vector": 54, "adam": 54, "objective_funct": 54, "get_result": 54, "temp": 55, "llvm": [55, 57, 58, 59], "qke": [55, 57], "pipelin": 55, "canonic": 55, "lift": 55, "indirect": 55, "direct": 55, "loader": 55, "expand": 55, "cfg": 55, "cse": 55, "lpsxpu": 55, "p3de4l": 55, "fixup": 55, "linkag": 55, "pl": [55, 59], "llc": [55, 59], "reloc": 55, "pic": 55, "filetyp": 55, "obj": 55, "o2": 55, "clang": [55, 59], "usr": [55, 59, 61], "lib": [55, 57, 58, 59, 61, 62, 65], "gcc": [55, 59, 61], "x86_64": [55, 59, 61, 65], "lib64": [55, 61, 63], "stub": 55, "wl": [55, 59], "rpath": 55, "llib": 55, "lcudaq": 55, "ensmallen": 55, "nlopt": 55, "em": 55, "lnvqir": 55, "orchestr": 55, "qtx": 55, "mangled_name_map": 55, "__nvqpp__mlirgen__ghz": 55, "_zn3ghzclei": 55, "i32": 55, "entrypoint": 55, "alloca": 55, "memref": 55, "extsi": 55, "c0_i32": 55, "c0_i32_0": 55, "alloca_1": 55, "c1_i32": 55, "subi": 55, "cmpi": 55, "slt": 55, "addi": 55, "unoptim": 55, "mangl": 55, "introspect": 55, "overwrit": 55, "libcudaq": 55, "libnvqir": [55, 58], "robust": 55, "intermedi": 55, "depart": 55, "recal": 55, "datalayout": 55, "p270": 55, "p271": 55, "p272": 55, "f80": 55, "n8": 55, "s128": 55, "unknown": [55, 61], "invokewithcontrolqubit": 55, "__quantum__qis__x__ctl": 55, "__quantum__rt__array_get_size_1d": 55, "__quantum__qis__h": 55, "i8": 55, "__quantum__rt__array_get_element_ptr_1d": 55, "sext": 55, "bitcast": 55, "icmp": 55, "sgt": 55, "br": 55, "ph": 55, "prehead": 55, "_crit_edg": 55, "pred": 55, "trip": 55, "zext": 55, "indvar": 55, "iv": 55, "nuw": 55, "nsw": 55, "nonnul": 55, "exitcond": 55, "ph3": 55, "_crit_edge4": 55, "exitcond5": 55, "pipe": 55, "analyz": 57, "directori": [57, 59, 61], "mycustomplugin": 57, "cmakelist": [57, 58, 62], "add_llvm_pass_plugin": 57, "operationpass": 57, "quakedialect": 57, "quakeop": 57, "rewrit": 57, "frozenrewritepatternset": 57, "dialectconvers": 57, "replaceh": 57, "oprewritepattern": 57, "hop": 57, "logicalresult": 57, "matchandrewrit": 57, "patternrewrit": 57, "replaceopwithnewop": 57, "sop": 57, "isadj": 57, "getparamet": 57, "getcontrol": 57, "gettarget": 57, "custompassplugin": 57, "passwrapp": 57, "funcop": 57, "mlir_define_explicit_internal_inline_type_id": 57, "stringref": 57, "runonoper": 57, "getoper": 57, "getcontext": 57, "rewritepatternset": 57, "insert": 57, "conversiontarget": 57, "addlegaldialect": 57, "addillegalop": 57, "applypartialconvers": 57, "emitoperror": 57, "signalpassfailur": 57, "cudaq_register_mlir_pass": 57, "add_subdirectori": 57, "walk": [58, 59, 61], "circuitsimulatorbas": 58, "lot": 58, "qppcircuitsimul": 58, "custateveccircuitsimul": 58, "openmp": [58, 59, 65], "addqubittost": 58, "addqubitstost": 58, "resetqubit": 58, "qubitidx": 58, "resetqubitstateimpl": 58, "applyg": 58, "gateapplicationtask": 58, "measurequbit": 58, "floattyp": 58, "mysimul": 58, "macro": 58, "nvqir_register_simul": 58, "mysimulatorclassnam": 58, "standalon": 58, "dylib": 58, "nvqir_simulation_backend": 58, "cuda_quantum_path": [58, 59, 61, 62], "find_packag": [58, 62], "nvqir_add_backend": 58, "folder": [58, 59, 61, 62], "cmake_minimum_requir": [58, 62], "fatal_error": [58, 62], "democreatenvqirbackend": 58, "cxx": [58, 59, 62, 65], "measuredbit": 58, "cuda_quantum": [58, 59], "mkdir": [58, 59, 62], "cd": [58, 59, 61, 62], "ninja": [58, 62], "dnvqir_dir": 58, "conflict": 59, "softwar": [59, 61], "rootless": 59, "admin": [59, 61], "permiss": [59, 61], "meet": 59, "carefulli": 59, "skip": 59, "almost": [59, 61], "though": 59, "piec": 59, "requisit": 59, "almalinux": 59, "manylinux_2_28": 59, "cento": [59, 61], "debian": [59, 61], "fedora": [59, 61], "opensus": [59, 61], "sled": [59, 61], "sle": [59, 61], "rhel": [59, 61], "rocki": [59, 61], "ubuntu": [59, 61], "04": [59, 61], "shell": [59, 61, 65], "newer": [59, 61, 65], "x86": [59, 61], "arm64": [59, 61, 65], "v8": [59, 61], "volta": [59, 61], "ture": [59, 61], "amper": [59, 61], "ada": [59, 61], "hopper": [59, 61], "smi": [59, 61], "470": [59, 61], "57": [59, 61], "02": [59, 61], "strongli": 59, "wget": [59, 61], "git": 59, "unzip": 59, "web": [59, 61], "cudaq_install_prefix": 59, "cuquantum_install_prefix": 59, "cutensor_install_prefix": 59, "cutensor": 59, "llvm_install_prefix": 59, "blas_install_prefix": 59, "bla": 59, "zlib_install_prefix": 59, "zlib": 59, "openssl_install_prefix": 59, "openssl": 59, "curl_install_prefix": 59, "protocol": 59, "deviat": 59, "toolkit": [59, 61, 63, 65], "onlin": [59, 61], "cuda_vers": [59, 61], "cuda_download_url": [59, 61], "repo": [59, 61], "subfold": [59, 61], "rhel8": [59, 61], "cuda_arch_fold": [59, 61], "dnf": [59, 61], "nobest": [59, 61], "setopt": [59, 61], "install_weak_dep": [59, 61], "tr": [59, 61], "gcc_version": 59, "toolset": 59, "gcc_install_prefix": 59, "rh": 59, "root": [59, 61], "fc": 59, "gfortran": 59, "cudacxx": 59, "nvcc": [59, 61, 63], "fortran": 59, "omit": 59, "commit": 59, "checkout": 59, "archiv": [59, 61], "subsect": 59, "cudaq_werror": 59, "cudaq_python_support": 59, "cudahostcxx": 59, "ldflag": 59, "libgcc": 59, "libstdc": [59, 61], "llvm_project": 59, "lld": 59, "build_cudaq": 59, "sh": [59, 61, 65], "uv": 59, "primarili": 59, "linker": 59, "makeself": 59, "cuda_quantum_asset": 59, "mv": 59, "ld": 59, "build_config": 59, "xml": 59, "gzip": [59, 61], "sha256": 59, "licens": [59, 61], "install_cuda_quantum": [59, 61, 65], "unam": [59, 61, 65], "migrate_asset": 59, "usual": [59, 61], "devel": 59, "suffix": 59, "conda": [59, 65], "auditwheel": 59, "patchelf": 59, "install_prerequisit": [59, 61], "histori": 59, "setuptools_scm_pretend_vers": 59, "cudaq_wheel": 59, "whl": 59, "manylinux_platform": 59, "linux_": 59, "sed": [59, 61], "manylinux_2_28_": 59, "pwd": 59, "_skbuild": 59, "repair": 59, "plat": 59, "libcubla": [59, 61], "libcublaslt": 59, "libcusolv": [59, 61], "libcutensor": 59, "libcutensornet": 59, "libcustatevec": 59, "libcudart": 59, "libnvidia": 59, "ml": 59, "wheelhous": 59, "inde": 59, "discover": [59, 61], "org": [59, 61], "sudo": [59, 61, 65], "set_env": [59, 61], "asset": [59, 61, 65], "highli": [59, 61], "profil": [59, 61, 65], "nvqpp_ld_path": 59, "did": [59, 61], "prefer": [59, 61], "version_suffix": [59, 61], "nvtx": [59, 61], "cudart": [59, 61], "awar": [59, 63], "autoconf": 59, "libtool": 59, "flex": 59, "openmpi_vers": 59, "openmpi_download_url": 59, "ompi": 59, "tar": [59, 61], "gz": [59, 61], "xf": 59, "strip": 59, "rf": [59, 61], "autogen": 59, "prefix": [59, 61], "getpwuid": 59, "mem": 59, "memcheck": 59, "verb": 59, "nproc": 59, "mpic": 59, "mpi_cuda_check": 59, "__has_includ": 59, "ext": 59, "endif": 59, "mpi_init": 59, "exit_cod": 59, "mpix_query_cuda_support": 59, "mpi_fin": 59, "mca": 59, "plm_rsh_agent": 59, "ssh": 59, "agent": 59, "rsh": 59, "unless": [59, 61], "slurm": 59, "mpi_path": [59, 61, 65], "distributed_interfac": [59, 61, 65], "activate_custom_mpi": [59, 61, 65], "yourself": 59, "guidanc": 61, "bundl": 61, "deploi": 61, "contribut": 61, "unsur": 61, "engin": 61, "desktop": 61, "administr": 61, "ngc": 61, "whenev": 61, "pull": 61, "nvcr": 61, "io": 61, "prototyp": 61, "tri": 61, "readm": 61, "appreci": 61, "insuffici": 61, "outsid": 61, "hover": 61, "rsa": 61, "id_rsa": 61, "pub": 61, "itd": 61, "2222": 61, "exec": 61, "openssh": 61, "usepam": 61, "sshd_config": 61, "cp": 61, "authorized_kei": 61, "sbin": 61, "sshd": 61, "stricthostkeycheck": 61, "userknownhostsfil": 61, "globalknownhostsfil": 61, "relocat": 61, "wsl": 61, "prerequisit": 61, "sylab": 61, "ce": 61, "xzf": 61, "mconfig": 61, "suid": 61, "builddir": 61, "bootstrap": 61, "runscript": 61, "mount": 61, "devpt": 61, "fakeroot": 61, "sif": 61, "writabl": 61, "nv": 61, "conf": 61, "ldd": 61, "privileg": 61, "revis": 61, "upvot": 61, "posix": 61, "certainli": 61, "easiest": 61, "search": 61, "browser": 61, "palett": 61, "attach": 61, "window": 61, "reload": 61, "microsoft": 61, "sandbox": 61, "portmap": 61, "sshd_output": 61, "listen": 61, "1025": 61, "65535": 61, "ui": 61, "encrypt": 61, "vscode": 61, "pop": 61, "ask": 61, "jupyt": 61, "aren": 61, "click": 61, "icon": 61, "sidebar": 61, "prompt": 61, "workspac": 61, "edit": 61, "remotecommand": 61, "requesttti": 61, "hostnam": 61, "enableremotecommand": 61, "uselocalserv": 61, "remoteserverlistenonsocket": 61, "connecttimeout": 61, "120": 61, "serverinstallpath": 61, "sign": 61, "upgrad": 61, "ac": 61, "ace_nam": 61, "instance_nam": 61, "commandlin": 61, "job_id": 61, "600": 61, "8888": 61, "lab": 61, "portal": 61, "minut": 61, "404": 61, "patient": 61, "happi": 61, "cuda11x": 61, "ship": 61, "vendor": 61, "prebuilt": 61, "guarante": 61, "libcudaq_distributed_interface_mpi": 61, "cudaq_mpi_comm_lib": 61, "uninstal": 61, "dsize": 61, "fairli": 61, "succe": 61, "proce": [61, 65], "sort": 62, "imper": 62, "mycudaqapp": 62, "add_execut": 62, "ghz_ex": 62, "dcudaq_dir": 62, "cu": 63, "my_proj": 63, "conform": 63, "my_proj_quantum": 63, "wrinkl": 63, "makefil": 63, "fortun": 63, "my_project_quantum": 63, "cuda_instal": 63, "lcudart": 63, "my_execut": 63, "forg": 65, "env": 65, "conda_prefix": 65, "ompi_mca_opal_cuda_support": 65, "ompi_mca_btl": 65, "openib": 65, "fault": 65, "bash_profil": 65, "bash_login": 65, "intel": 65, "amd": 65, "averag": 65}, "objects": {"": [[2, 0, 1, "_CPPv45cudaq", "cudaq"], [2, 1, 1, "_CPPv4N5cudaq20BaseNvcfSimulatorQPUE", "cudaq::BaseNvcfSimulatorQPU"], [2, 1, 1, "_CPPv4N5cudaq17BaseRemoteRESTQPUE", "cudaq::BaseRemoteRESTQPU"], [2, 1, 1, "_CPPv4N5cudaq22BaseRemoteSimulatorQPUE", "cudaq::BaseRemoteSimulatorQPU"], [2, 1, 1, "_CPPv4I0EN5cudaq9CusvStateE", "cudaq::CusvState"], [2, 2, 1, "_CPPv4I0EN5cudaq9CusvStateE", "cudaq::CusvState::ScalarType"], [2, 1, 1, "_CPPv4N5cudaq16ExecutionContextE", "cudaq::ExecutionContext"], [2, 3, 1, "_CPPv4N5cudaq16ExecutionContext16ExecutionContextEKNSt6stringE", "cudaq::ExecutionContext::ExecutionContext"], [2, 3, 1, "_CPPv4N5cudaq16ExecutionContext16ExecutionContextEKNSt6stringENSt6size_tE", "cudaq::ExecutionContext::ExecutionContext"], [2, 4, 1, "_CPPv4N5cudaq16ExecutionContext16ExecutionContextEKNSt6stringE", "cudaq::ExecutionContext::ExecutionContext::n"], [2, 4, 1, "_CPPv4N5cudaq16ExecutionContext16ExecutionContextEKNSt6stringENSt6size_tE", "cudaq::ExecutionContext::ExecutionContext::n"], [2, 4, 1, "_CPPv4N5cudaq16ExecutionContext16ExecutionContextEKNSt6stringENSt6size_tE", "cudaq::ExecutionContext::ExecutionContext::shots_"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext13amplitudeMapsE", "cudaq::ExecutionContext::amplitudeMaps"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext9asyncExecE", "cudaq::ExecutionContext::asyncExec"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext14batchIterationE", "cudaq::ExecutionContext::batchIteration"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext16canHandleObserveE", "cudaq::ExecutionContext::canHandleObserve"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext16expectationValueE", "cudaq::ExecutionContext::expectationValue"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext12futureResultE", "cudaq::ExecutionContext::futureResult"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext31hasConditionalsOnMeasureResultsE", "cudaq::ExecutionContext::hasConditionalsOnMeasureResults"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext22invocationResultBufferE", "cudaq::ExecutionContext::invocationResultBuffer"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext10kernelNameE", "cudaq::ExecutionContext::kernelName"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext11kernelTraceE", "cudaq::ExecutionContext::kernelTrace"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext4nameE", "cudaq::ExecutionContext::name"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext10noiseModelE", "cudaq::ExecutionContext::noiseModel"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext9optResultE", "cudaq::ExecutionContext::optResult"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext20overlapComputeStatesE", "cudaq::ExecutionContext::overlapComputeStates"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext13overlapResultE", "cudaq::ExecutionContext::overlapResult"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext13registerNamesE", "cudaq::ExecutionContext::registerNames"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext10reorderIdxE", "cudaq::ExecutionContext::reorderIdx"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext6resultE", "cudaq::ExecutionContext::result"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext5shotsE", "cudaq::ExecutionContext::shots"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext15simulationStateE", "cudaq::ExecutionContext::simulationState"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext4spinE", "cudaq::ExecutionContext::spin"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext15totalIterationsE", "cudaq::ExecutionContext::totalIterations"], [2, 1, 1, "_CPPv4N5cudaq15ExecutionResultE", "cudaq::ExecutionResult"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionary", "cudaq::ExecutionResult::ExecutionResult"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryNSt6stringE", "cudaq::ExecutionResult::ExecutionResult"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryd", "cudaq::ExecutionResult::ExecutionResult"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultENSt6stringE", "cudaq::ExecutionResult::ExecutionResult"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultERK15ExecutionResult", "cudaq::ExecutionResult::ExecutionResult"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultEd", "cudaq::ExecutionResult::ExecutionResult"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultEv", "cudaq::ExecutionResult::ExecutionResult"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionary", "cudaq::ExecutionResult::ExecutionResult::c"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryNSt6stringE", "cudaq::ExecutionResult::ExecutionResult::c"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryd", "cudaq::ExecutionResult::ExecutionResult::c"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryd", "cudaq::ExecutionResult::ExecutionResult::e"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultEd", "cudaq::ExecutionResult::ExecutionResult::expVal"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryNSt6stringE", "cudaq::ExecutionResult::ExecutionResult::name"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultENSt6stringE", "cudaq::ExecutionResult::ExecutionResult::name"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultERK15ExecutionResult", "cudaq::ExecutionResult::ExecutionResult::other"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult12appendResultENSt6stringENSt6size_tE", "cudaq::ExecutionResult::appendResult"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult12appendResultENSt6stringENSt6size_tE", "cudaq::ExecutionResult::appendResult::bitString"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult12appendResultENSt6stringENSt6size_tE", "cudaq::ExecutionResult::appendResult::count"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult11deserializeERNSt6vectorINSt6size_tEEE", "cudaq::ExecutionResult::deserialize"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult11deserializeERNSt6vectorINSt6size_tEEE", "cudaq::ExecutionResult::deserialize::data"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResultaSERK15ExecutionResult", "cudaq::ExecutionResult::operator="], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResultaSERK15ExecutionResult", "cudaq::ExecutionResult::operator=::other"], [2, 3, 1, "_CPPv4NK5cudaq15ExecutionResulteqERK15ExecutionResult", "cudaq::ExecutionResult::operator=="], [2, 4, 1, "_CPPv4NK5cudaq15ExecutionResulteqERK15ExecutionResult", "cudaq::ExecutionResult::operator==::result"], [2, 5, 1, "_CPPv4N5cudaq15ExecutionResult12registerNameE", "cudaq::ExecutionResult::registerName"], [2, 5, 1, "_CPPv4N5cudaq15ExecutionResult14sequentialDataE", "cudaq::ExecutionResult::sequentialData"], [2, 3, 1, "_CPPv4NK5cudaq15ExecutionResult9serializeEv", "cudaq::ExecutionResult::serialize"], [2, 0, 1, "_CPPv4N5cudaq19KernelExecutionTaskE", "cudaq::KernelExecutionTask"], [2, 1, 1, "_CPPv4N5cudaq3QPUE", "cudaq::QPU"], [2, 3, 1, "_CPPv4N5cudaq3QPU3QPUENSt6size_tE", "cudaq::QPU::QPU"], [2, 3, 1, "_CPPv4N5cudaq3QPU3QPUERR3QPU", "cudaq::QPU::QPU"], [2, 3, 1, "_CPPv4N5cudaq3QPU3QPUEv", "cudaq::QPU::QPU"], [2, 4, 1, "_CPPv4N5cudaq3QPU3QPUENSt6size_tE", "cudaq::QPU::QPU::_qpuId"], [2, 3, 1, "_CPPv4N5cudaq3QPU7enqueueER11QuantumTask", "cudaq::QPU::enqueue"], [2, 4, 1, "_CPPv4N5cudaq3QPU7enqueueER11QuantumTask", "cudaq::QPU::enqueue::task"], [2, 3, 1, "_CPPv4N5cudaq3QPU15getConnectivityEv", "cudaq::QPU::getConnectivity"], [2, 3, 1, "_CPPv4NK5cudaq3QPU20getExecutionThreadIdEv", "cudaq::QPU::getExecutionThreadId"], [2, 3, 1, "_CPPv4N5cudaq3QPU12getNumQubitsEv", "cudaq::QPU::getNumQubits"], [2, 3, 1, "_CPPv4NK5cudaq3QPU21getRemoteCapabilitiesEv", "cudaq::QPU::getRemoteCapabilities"], [2, 3, 1, "_CPPv4N5cudaq3QPU10isEmulatedEv", "cudaq::QPU::isEmulated"], [2, 3, 1, "_CPPv4N5cudaq3QPU11isSimulatorEv", "cudaq::QPU::isSimulator"], [2, 3, 1, "_CPPv4N5cudaq3QPU12launchKernelERKNSt6stringEPFvPvEPvNSt8uint64_tENSt8uint64_tE", "cudaq::QPU::launchKernel"], [2, 4, 1, "_CPPv4N5cudaq3QPU12launchKernelERKNSt6stringEPFvPvEPvNSt8uint64_tENSt8uint64_tE", "cudaq::QPU::launchKernel::args"], [2, 4, 1, "_CPPv4N5cudaq3QPU12launchKernelERKNSt6stringEPFvPvEPvNSt8uint64_tENSt8uint64_tE", "cudaq::QPU::launchKernel::kernelFunc"], [2, 4, 1, "_CPPv4N5cudaq3QPU12launchKernelERKNSt6stringEPFvPvEPvNSt8uint64_tENSt8uint64_tE", "cudaq::QPU::launchKernel::name"], [2, 3, 1, "_CPPv4N5cudaq3QPU29launchSerializedCodeExecutionERKNSt6stringERN5cudaq30SerializedCodeExecutionContextE", "cudaq::QPU::launchSerializedCodeExecution"], [2, 4, 1, "_CPPv4N5cudaq3QPU29launchSerializedCodeExecutionERKNSt6stringERN5cudaq30SerializedCodeExecutionContextE", "cudaq::QPU::launchSerializedCodeExecution::name"], [2, 4, 1, "_CPPv4N5cudaq3QPU29launchSerializedCodeExecutionERKNSt6stringERN5cudaq30SerializedCodeExecutionContextE", "cudaq::QPU::launchSerializedCodeExecution::serializeCodeExecutionObject"], [2, 3, 1, "_CPPv4N5cudaq3QPU15onRandomSeedSetENSt6size_tE", "cudaq::QPU::onRandomSeedSet"], [2, 4, 1, "_CPPv4N5cudaq3QPU15onRandomSeedSetENSt6size_tE", "cudaq::QPU::onRandomSeedSet::seed"], [2, 3, 1, "_CPPv4N5cudaq3QPU21resetExecutionContextEv", "cudaq::QPU::resetExecutionContext"], [2, 3, 1, "_CPPv4N5cudaq3QPU19setExecutionContextEP16ExecutionContext", "cudaq::QPU::setExecutionContext"], [2, 4, 1, "_CPPv4N5cudaq3QPU19setExecutionContextEP16ExecutionContext", "cudaq::QPU::setExecutionContext::context"], [2, 3, 1, "_CPPv4N5cudaq3QPU5setIdENSt6size_tE", "cudaq::QPU::setId"], [2, 4, 1, "_CPPv4N5cudaq3QPU5setIdENSt6size_tE", "cudaq::QPU::setId::_qpuId"], [2, 3, 1, "_CPPv4N5cudaq3QPU8setShotsEi", "cudaq::QPU::setShots"], [2, 4, 1, "_CPPv4N5cudaq3QPU8setShotsEi", "cudaq::QPU::setShots::_nShots"], [2, 3, 1, "_CPPv4N5cudaq3QPU27supportsConditionalFeedbackEv", "cudaq::QPU::supportsConditionalFeedback"], [2, 3, 1, "_CPPv4N5cudaq3QPUD0Ev", "cudaq::QPU::~QPU"], [2, 1, 1, "_CPPv4N5cudaq10QuakeValueE", "cudaq::QuakeValue"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEN4mlir5ValueE", "cudaq::QuakeValue::QuakeValue"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEd", "cudaq::QuakeValue::QuakeValue"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEN4mlir5ValueE", "cudaq::QuakeValue::QuakeValue::builder"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEd", "cudaq::QuakeValue::QuakeValue::builder"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEN4mlir5ValueE", "cudaq::QuakeValue::QuakeValue::v"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEd", "cudaq::QuakeValue::QuakeValue::v"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue22canValidateNumElementsEv", "cudaq::QuakeValue::canValidateNumElements"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue12constantSizeEv", "cudaq::QuakeValue::constantSize"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue4dumpERNSt7ostreamE", "cudaq::QuakeValue::dump"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue4dumpEv", "cudaq::QuakeValue::dump"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue19getRequiredElementsEv", "cudaq::QuakeValue::getRequiredElements"], [2, 3, 1, "_CPPv4NK5cudaq10QuakeValue8getValueEv", "cudaq::QuakeValue::getValue"], [2, 3, 1, "_CPPv4NK5cudaq10QuakeValue7inverseEv", "cudaq::QuakeValue::inverse"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue8isStdVecEv", "cudaq::QuakeValue::isStdVec"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValuemlE10QuakeValue", "cudaq::QuakeValue::operator*"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValuemlEKd", "cudaq::QuakeValue::operator*"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValuemlE10QuakeValue", "cudaq::QuakeValue::operator*::other"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValueplE10QuakeValue", "cudaq::QuakeValue::operator+"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValueplEKd", "cudaq::QuakeValue::operator+"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValueplEKi", "cudaq::QuakeValue::operator+"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValueplE10QuakeValue", "cudaq::QuakeValue::operator+::other"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValuemiE10QuakeValue", "cudaq::QuakeValue::operator-"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValuemiEKd", "cudaq::QuakeValue::operator-"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValuemiEKi", "cudaq::QuakeValue::operator-"], [2, 3, 1, "_CPPv4NK5cudaq10QuakeValuemiEv", "cudaq::QuakeValue::operator-"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValuemiE10QuakeValue", "cudaq::QuakeValue::operator-::other"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValuedvE10QuakeValue", "cudaq::QuakeValue::operator/"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValuedvEKd", "cudaq::QuakeValue::operator/"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValuedvE10QuakeValue", "cudaq::QuakeValue::operator/::other"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValueixEKNSt6size_tE", "cudaq::QuakeValue::operator[]"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValueixERK10QuakeValue", "cudaq::QuakeValue::operator[]"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValueixEKNSt6size_tE", "cudaq::QuakeValue::operator[]::idx"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValueixERK10QuakeValue", "cudaq::QuakeValue::operator[]::idx"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue4sizeEv", "cudaq::QuakeValue::size"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue5sliceEKNSt6size_tEKNSt6size_tE", "cudaq::QuakeValue::slice"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValue5sliceEKNSt6size_tEKNSt6size_tE", "cudaq::QuakeValue::slice::count"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValue5sliceEKNSt6size_tEKNSt6size_tE", "cudaq::QuakeValue::slice::startIdx"], [2, 0, 1, "_CPPv4N5cudaq11QuantumTaskE", "cudaq::QuantumTask"], [2, 0, 1, "_CPPv4N5cudaq17QubitConnectivityE", "cudaq::QubitConnectivity"], [2, 0, 1, "_CPPv4N5cudaq9QubitEdgeE", "cudaq::QubitEdge"], [2, 1, 1, "_CPPv4N5cudaq18RemoteCapabilitiesE", "cudaq::RemoteCapabilities"], [2, 3, 1, "_CPPv4N5cudaq18RemoteCapabilities18RemoteCapabilitiesEb", "cudaq::RemoteCapabilities::RemoteCapabilities"], [2, 4, 1, "_CPPv4N5cudaq18RemoteCapabilities18RemoteCapabilitiesEb", "cudaq::RemoteCapabilities::RemoteCapabilities::initValue"], [2, 5, 1, "_CPPv4N5cudaq18RemoteCapabilities18serializedCodeExecE", "cudaq::RemoteCapabilities::serializedCodeExec"], [2, 5, 1, "_CPPv4N5cudaq18RemoteCapabilities12stateOverlapE", "cudaq::RemoteCapabilities::stateOverlap"], [2, 5, 1, "_CPPv4N5cudaq18RemoteCapabilities3vqeE", "cudaq::RemoteCapabilities::vqe"], [2, 1, 1, "_CPPv4N5cudaq21RemoteSimulationStateE", "cudaq::RemoteSimulationState"], [2, 1, 1, "_CPPv4N5cudaq9ResourcesE", "cudaq::Resources"], [2, 1, 1, "_CPPv4N5cudaq30SerializedCodeExecutionContextE", "cudaq::SerializedCodeExecutionContext"], [2, 1, 1, "_CPPv4N5cudaq15SimulationStateE", "cudaq::SimulationState"], [2, 1, 1, "_CPPv4N5cudaq15SimulationState6TensorE", "cudaq::SimulationState::Tensor"], [2, 6, 1, "_CPPv4N5cudaq15SimulationState9precisionE", "cudaq::SimulationState::precision"], [2, 7, 1, "_CPPv4N5cudaq15SimulationState9precision4fp32E", "cudaq::SimulationState::precision::fp32"], [2, 7, 1, "_CPPv4N5cudaq15SimulationState9precision4fp64E", "cudaq::SimulationState::precision::fp64"], [2, 0, 1, "_CPPv4N5cudaq15TensorStateDataE", "cudaq::TensorStateData"], [2, 1, 1, "_CPPv4N5cudaq5TraceE", "cudaq::Trace"], [2, 1, 1, "_CPPv4N5cudaq25amplitude_damping_channelE", "cudaq::amplitude_damping_channel"], [2, 1, 1, "_CPPv4I0EN5cudaq12async_resultE", "cudaq::async_result"], [2, 2, 1, "_CPPv4I0EN5cudaq12async_resultE", "cudaq::async_result::T"], [2, 3, 1, "_CPPv4N5cudaq12async_result3getEv", "cudaq::async_result::get"], [2, 1, 1, "_CPPv4N5cudaq16bit_flip_channelE", "cudaq::bit_flip_channel"], [2, 0, 1, "_CPPv4N5cudaq7complexE", "cudaq::complex"], [2, 1, 1, "_CPPv4N5cudaq14complex_matrixE", "cudaq::complex_matrix"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrix4colsEv", "cudaq::complex_matrix::cols"], [2, 3, 1, "_CPPv4N5cudaq14complex_matrix14complex_matrixEKNSt6size_tEKNSt6size_tE", "cudaq::complex_matrix::complex_matrix"], [2, 3, 1, "_CPPv4N5cudaq14complex_matrix14complex_matrixEP10value_typeKNSt6size_tEKNSt6size_tE", "cudaq::complex_matrix::complex_matrix"], [2, 4, 1, "_CPPv4N5cudaq14complex_matrix14complex_matrixEKNSt6size_tEKNSt6size_tE", "cudaq::complex_matrix::complex_matrix::cols"], [2, 4, 1, "_CPPv4N5cudaq14complex_matrix14complex_matrixEP10value_typeKNSt6size_tEKNSt6size_tE", "cudaq::complex_matrix::complex_matrix::cols"], [2, 4, 1, "_CPPv4N5cudaq14complex_matrix14complex_matrixEP10value_typeKNSt6size_tEKNSt6size_tE", "cudaq::complex_matrix::complex_matrix::rawData"], [2, 4, 1, "_CPPv4N5cudaq14complex_matrix14complex_matrixEKNSt6size_tEKNSt6size_tE", "cudaq::complex_matrix::complex_matrix::rows"], [2, 4, 1, "_CPPv4N5cudaq14complex_matrix14complex_matrixEP10value_typeKNSt6size_tEKNSt6size_tE", "cudaq::complex_matrix::complex_matrix::rows"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrix4dataEv", "cudaq::complex_matrix::data"], [2, 3, 1, "_CPPv4N5cudaq14complex_matrix4dumpERNSt7ostreamE", "cudaq::complex_matrix::dump"], [2, 3, 1, "_CPPv4N5cudaq14complex_matrix4dumpEv", "cudaq::complex_matrix::dump"], [2, 4, 1, "_CPPv4N5cudaq14complex_matrix4dumpERNSt7ostreamE", "cudaq::complex_matrix::dump::os"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrix11eigenvaluesEv", "cudaq::complex_matrix::eigenvalues"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrix12eigenvectorsEv", "cudaq::complex_matrix::eigenvectors"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrix18minimal_eigenvalueEv", "cudaq::complex_matrix::minimal_eigenvalue"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrixclENSt6size_tENSt6size_tE", "cudaq::complex_matrix::operator()"], [2, 4, 1, "_CPPv4NK5cudaq14complex_matrixclENSt6size_tENSt6size_tE", "cudaq::complex_matrix::operator()::i"], [2, 4, 1, "_CPPv4NK5cudaq14complex_matrixclENSt6size_tENSt6size_tE", "cudaq::complex_matrix::operator()::j"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrixmlER14complex_matrix", "cudaq::complex_matrix::operator*"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrixmlERNSt6vectorI10value_typeEE", "cudaq::complex_matrix::operator*"], [2, 4, 1, "_CPPv4NK5cudaq14complex_matrixmlER14complex_matrix", "cudaq::complex_matrix::operator*::other"], [2, 4, 1, "_CPPv4NK5cudaq14complex_matrixmlERNSt6vectorI10value_typeEE", "cudaq::complex_matrix::operator*::other"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrix4rowsEv", "cudaq::complex_matrix::rows"], [2, 3, 1, "_CPPv4N5cudaq14complex_matrix8set_zeroEv", "cudaq::complex_matrix::set_zero"], [2, 0, 1, "_CPPv4N5cudaq14complex_matrix10value_typeE", "cudaq::complex_matrix::value_type"], [2, 1, 1, "_CPPv4N5cudaq22depolarization_channelE", "cudaq::depolarization_channel"], [2, 0, 1, "_CPPv4N5cudaq7detailsE", "cudaq::details"], [2, 1, 1, "_CPPv4N5cudaq7details17KernelBuilderTypeE", "cudaq::details::KernelBuilderType"], [2, 3, 1, "_CPPv4N5cudaq7details17KernelBuilderType17KernelBuilderTypeERRNSt8functionIFN4mlir4TypeEPN4mlir11MLIRContextEEEE", "cudaq::details::KernelBuilderType::KernelBuilderType"], [2, 4, 1, "_CPPv4N5cudaq7details17KernelBuilderType17KernelBuilderTypeERRNSt8functionIFN4mlir4TypeEPN4mlir11MLIRContextEEEE", "cudaq::details::KernelBuilderType::KernelBuilderType::f"], [2, 3, 1, "_CPPv4N5cudaq7details17KernelBuilderType6createEPN4mlir11MLIRContextE", "cudaq::details::KernelBuilderType::create"], [2, 4, 1, "_CPPv4N5cudaq7details17KernelBuilderType6createEPN4mlir11MLIRContextE", "cudaq::details::KernelBuilderType::create::ctx"], [2, 1, 1, "_CPPv4N5cudaq7details6futureE", "cudaq::details::future"], [2, 3, 1, "_CPPv4N5cudaq7details6future6futureERNSt6vectorI3JobEERNSt6stringERNSt3mapINSt6stringENSt6stringEEE", "cudaq::details::future::future"], [2, 3, 1, "_CPPv4N5cudaq7details6future6futureERR6future", "cudaq::details::future::future"], [2, 3, 1, "_CPPv4N5cudaq7details6future6futureEv", "cudaq::details::future::future"], [2, 4, 1, "_CPPv4N5cudaq7details6future6futureERNSt6vectorI3JobEERNSt6stringERNSt3mapINSt6stringENSt6stringEEE", "cudaq::details::future::future::_jobs"], [2, 4, 1, "_CPPv4N5cudaq7details6future6futureERNSt6vectorI3JobEERNSt6stringERNSt3mapINSt6stringENSt6stringEEE", "cudaq::details::future::future::config"], [2, 4, 1, "_CPPv4N5cudaq7details6future6futureERNSt6vectorI3JobEERNSt6stringERNSt3mapINSt6stringENSt6stringEEE", "cudaq::details::future::future::qpuNameIn"], [2, 1, 1, "_CPPv4N5cudaq7details19kernel_builder_baseE", "cudaq::details::kernel_builder_base"], [2, 3, 1, "_CPPv4N5cudaq7details19kernel_builder_baselsERNSt7ostreamERK19kernel_builder_base", "cudaq::details::kernel_builder_base::operator<<"], [2, 4, 1, "_CPPv4N5cudaq7details19kernel_builder_baselsERNSt7ostreamERK19kernel_builder_base", "cudaq::details::kernel_builder_base::operator<<::builder"], [2, 4, 1, "_CPPv4N5cudaq7details19kernel_builder_baselsERNSt7ostreamERK19kernel_builder_base", "cudaq::details::kernel_builder_base::operator<<::stream"], [2, 3, 1, "_CPPv4I0Dp0EN5cudaq4drawENSt6stringERR13QuantumKernelDpRR4Args", "cudaq::draw"], [2, 2, 1, "_CPPv4I0Dp0EN5cudaq4drawENSt6stringERR13QuantumKernelDpRR4Args", "cudaq::draw::Args"], [2, 2, 1, "_CPPv4I0Dp0EN5cudaq4drawENSt6stringERR13QuantumKernelDpRR4Args", "cudaq::draw::QuantumKernel"], [2, 4, 1, "_CPPv4I0Dp0EN5cudaq4drawENSt6stringERR13QuantumKernelDpRR4Args", "cudaq::draw::args"], [2, 4, 1, "_CPPv4I0Dp0EN5cudaq4drawENSt6stringERR13QuantumKernelDpRR4Args", "cudaq::draw::kernel"], [2, 5, 1, "_CPPv4N5cudaq3dynE", "cudaq::dyn"], [2, 1, 1, "_CPPv4N5cudaq8gradientE", "cudaq::gradient"], [2, 3, 1, "_CPPv4N5cudaq8gradient5cloneEv", "cudaq::gradient::clone"], [2, 3, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradient::compute"], [2, 3, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradient::compute"], [2, 4, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradient::compute::dx"], [2, 4, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradient::compute::func"], [2, 4, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradient::compute::funcAtX"], [2, 4, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradient::compute::funcAtX"], [2, 4, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradient::compute::h"], [2, 4, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradient::compute::x"], [2, 4, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradient::compute::x"], [2, 3, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelT", "cudaq::gradient::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelTRR10ArgsMapper", "cudaq::gradient::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq8gradient8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradient::gradient"], [2, 3, 1, "_CPPv4N5cudaq8gradient8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradient::gradient"], [2, 3, 1, "_CPPv4N5cudaq8gradient8gradientEv", "cudaq::gradient::gradient"], [2, 2, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelTRR10ArgsMapper", "cudaq::gradient::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq8gradient8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradient::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelT", "cudaq::gradient::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelTRR10ArgsMapper", "cudaq::gradient::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq8gradient8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradient::gradient::QuantumKernel"], [2, 4, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelTRR10ArgsMapper", "cudaq::gradient::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq8gradient8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradient::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelT", "cudaq::gradient::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelTRR10ArgsMapper", "cudaq::gradient::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq8gradient8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradient::gradient::kernel"], [2, 4, 1, "_CPPv4N5cudaq8gradient8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradient::gradient::kernel"], [2, 3, 1, "_CPPv4I0DpEN5cudaq8gradient7setArgsEvR13QuantumKernelDpRR4Args", "cudaq::gradient::setArgs"], [2, 2, 1, "_CPPv4I0DpEN5cudaq8gradient7setArgsEvR13QuantumKernelDpRR4Args", "cudaq::gradient::setArgs::Args"], [2, 2, 1, "_CPPv4I0DpEN5cudaq8gradient7setArgsEvR13QuantumKernelDpRR4Args", "cudaq::gradient::setArgs::QuantumKernel"], [2, 4, 1, "_CPPv4I0DpEN5cudaq8gradient7setArgsEvR13QuantumKernelDpRR4Args", "cudaq::gradient::setArgs::args"], [2, 4, 1, "_CPPv4I0DpEN5cudaq8gradient7setArgsEvR13QuantumKernelDpRR4Args", "cudaq::gradient::setArgs::kernel"], [2, 3, 1, "_CPPv4I0EN5cudaq8gradient9setKernelEvR13QuantumKernel", "cudaq::gradient::setKernel"], [2, 2, 1, "_CPPv4I0EN5cudaq8gradient9setKernelEvR13QuantumKernel", "cudaq::gradient::setKernel::QuantumKernel"], [2, 4, 1, "_CPPv4I0EN5cudaq8gradient9setKernelEvR13QuantumKernel", "cudaq::gradient::setKernel::kernel"], [2, 1, 1, "_CPPv4N5cudaq9gradients18central_differenceE", "cudaq::gradients::central_difference"], [2, 3, 1, "_CPPv4N5cudaq9gradients18central_difference5cloneEv", "cudaq::gradients::central_difference::clone"], [2, 3, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::central_difference::compute"], [2, 3, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::central_difference::compute"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::central_difference::compute::dx"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::central_difference::compute::exp_h"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::central_difference::compute::func"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::central_difference::compute::funcAtX"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::central_difference::compute::h"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::central_difference::compute::x"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::central_difference::compute::x"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelT", "cudaq::gradients::central_difference::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::central_difference::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::central_difference::gradient"], [2, 3, 1, "_CPPv4N5cudaq9gradients18central_difference8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradients::central_difference::gradient"], [2, 3, 1, "_CPPv4N5cudaq9gradients18central_difference8gradientEv", "cudaq::gradients::central_difference::gradient"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelT", "cudaq::gradients::central_difference::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::QuantumKernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelT", "cudaq::gradients::central_difference::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::kernel"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradients::central_difference::gradient::kernel"], [2, 1, 1, "_CPPv4N5cudaq9gradients18forward_differenceE", "cudaq::gradients::forward_difference"], [2, 3, 1, "_CPPv4N5cudaq9gradients18forward_difference5cloneEv", "cudaq::gradients::forward_difference::clone"], [2, 3, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::forward_difference::compute"], [2, 3, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::forward_difference::compute"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::forward_difference::compute::dx"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::forward_difference::compute::func"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::forward_difference::compute::funcAtX"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::forward_difference::compute::funcAtX"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::forward_difference::compute::h"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::forward_difference::compute::x"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::forward_difference::compute::x"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelT", "cudaq::gradients::forward_difference::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient"], [2, 3, 1, "_CPPv4N5cudaq9gradients18forward_difference8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradients::forward_difference::gradient"], [2, 3, 1, "_CPPv4N5cudaq9gradients18forward_difference8gradientEv", "cudaq::gradients::forward_difference::gradient"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelT", "cudaq::gradients::forward_difference::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::QuantumKernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelT", "cudaq::gradients::forward_difference::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::kernel"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradients::forward_difference::gradient::kernel"], [2, 1, 1, "_CPPv4N5cudaq9gradients15parameter_shiftE", "cudaq::gradients::parameter_shift"], [2, 3, 1, "_CPPv4N5cudaq9gradients15parameter_shift5cloneEv", "cudaq::gradients::parameter_shift::clone"], [2, 3, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::parameter_shift::compute"], [2, 3, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::parameter_shift::compute"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::parameter_shift::compute::dx"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::parameter_shift::compute::exp_h"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::parameter_shift::compute::func"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::parameter_shift::compute::funcAtX"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::parameter_shift::compute::h"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::parameter_shift::compute::x"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::parameter_shift::compute::x"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelT", "cudaq::gradients::parameter_shift::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient"], [2, 3, 1, "_CPPv4N5cudaq9gradients15parameter_shift8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradients::parameter_shift::gradient"], [2, 3, 1, "_CPPv4N5cudaq9gradients15parameter_shift8gradientEv", "cudaq::gradients::parameter_shift::gradient"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelT", "cudaq::gradients::parameter_shift::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::QuantumKernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelT", "cudaq::gradients::parameter_shift::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::kernel"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradients::parameter_shift::gradient::kernel"], [2, 1, 1, "_CPPv4IDpEN5cudaq14kernel_builderE", "cudaq::kernel_builder"], [2, 2, 1, "_CPPv4IDpEN5cudaq14kernel_builderE", "cudaq::kernel_builder::Args"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder11constantValEd", "cudaq::kernel_builder::constantVal"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder11constantValEd", "cudaq::kernel_builder::constantVal::val"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder12getArgumentsEv", "cudaq::kernel_builder::getArguments"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder12getNumParamsEv", "cudaq::kernel_builder::getNumParams"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder11isArgStdVecENSt6size_tE", "cudaq::kernel_builder::isArgStdVec"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder11isArgStdVecENSt6size_tE", "cudaq::kernel_builder::isArgStdVec::idx"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder14kernel_builderERNSt6vectorIN7details17KernelBuilderTypeEEE", "cudaq::kernel_builder::kernel_builder"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder14kernel_builderERNSt6vectorIN7details17KernelBuilderTypeEEE", "cudaq::kernel_builder::kernel_builder::types"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder4nameEv", "cudaq::kernel_builder::name"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder6qallocE10QuakeValue", "cudaq::kernel_builder::qalloc"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder6qallocEKNSt6size_tE", "cudaq::kernel_builder::qalloc"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder6qallocERNSt6vectorINSt7complexIdEEEE", "cudaq::kernel_builder::qalloc"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder6qallocEv", "cudaq::kernel_builder::qalloc"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder6qallocEKNSt6size_tE", "cudaq::kernel_builder::qalloc::nQubits"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder6qallocE10QuakeValue", "cudaq::kernel_builder::qalloc::size"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder6qallocERNSt6vectorINSt7complexIdEEEE", "cudaq::kernel_builder::qalloc::state"], [2, 3, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRK10QuakeValueRK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap"], [2, 3, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRKNSt6vectorI10QuakeValueEERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder4swapERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap"], [2, 4, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRK10QuakeValueRK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::control"], [2, 4, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRKNSt6vectorI10QuakeValueEERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::controls"], [2, 4, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRK10QuakeValueRK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::first"], [2, 4, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRKNSt6vectorI10QuakeValueEERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::first"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder4swapERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::first"], [2, 2, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRK10QuakeValueRK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::mod"], [2, 2, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRKNSt6vectorI10QuakeValueEERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::mod"], [2, 4, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRK10QuakeValueRK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::second"], [2, 4, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRKNSt6vectorI10QuakeValueEERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::second"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder4swapERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::second"], [2, 1, 1, "_CPPv4N5cudaq13kraus_channelE", "cudaq::kraus_channel"], [2, 3, 1, "_CPPv4NK5cudaq13kraus_channel5emptyEv", "cudaq::kraus_channel::empty"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channel7get_opsEv", "cudaq::kraus_channel::get_ops"], [2, 3, 1, "_CPPv4IDpEN5cudaq13kraus_channel13kraus_channelEDpRRNSt16initializer_listI1TEE", "cudaq::kraus_channel::kraus_channel"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channel13kraus_channelERK13kraus_channel", "cudaq::kraus_channel::kraus_channel"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channel13kraus_channelERNSt6vectorI8kraus_opEE", "cudaq::kraus_channel::kraus_channel"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channel13kraus_channelERRNSt6vectorI8kraus_opEE", "cudaq::kraus_channel::kraus_channel"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channel13kraus_channelEv", "cudaq::kraus_channel::kraus_channel"], [2, 2, 1, "_CPPv4IDpEN5cudaq13kraus_channel13kraus_channelEDpRRNSt16initializer_listI1TEE", "cudaq::kraus_channel::kraus_channel::T"], [2, 4, 1, "_CPPv4IDpEN5cudaq13kraus_channel13kraus_channelEDpRRNSt16initializer_listI1TEE", "cudaq::kraus_channel::kraus_channel::inputLists"], [2, 4, 1, "_CPPv4N5cudaq13kraus_channel13kraus_channelERNSt6vectorI8kraus_opEE", "cudaq::kraus_channel::kraus_channel::ops"], [2, 4, 1, "_CPPv4N5cudaq13kraus_channel13kraus_channelERRNSt6vectorI8kraus_opEE", "cudaq::kraus_channel::kraus_channel::ops"], [2, 4, 1, "_CPPv4N5cudaq13kraus_channel13kraus_channelERK13kraus_channel", "cudaq::kraus_channel::kraus_channel::other"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channelaSERK13kraus_channel", "cudaq::kraus_channel::operator="], [2, 4, 1, "_CPPv4N5cudaq13kraus_channelaSERK13kraus_channel", "cudaq::kraus_channel::operator=::other"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channelixEKNSt6size_tE", "cudaq::kraus_channel::operator[]"], [2, 4, 1, "_CPPv4N5cudaq13kraus_channelixEKNSt6size_tE", "cudaq::kraus_channel::operator[]::idx"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channel9push_backE8kraus_op", "cudaq::kraus_channel::push_back"], [2, 4, 1, "_CPPv4N5cudaq13kraus_channel9push_backE8kraus_op", "cudaq::kraus_channel::push_back::op"], [2, 3, 1, "_CPPv4NK5cudaq13kraus_channel4sizeEv", "cudaq::kraus_channel::size"], [2, 1, 1, "_CPPv4N5cudaq8kraus_opE", "cudaq::kraus_op"], [2, 3, 1, "_CPPv4NK5cudaq8kraus_op7adjointEv", "cudaq::kraus_op::adjoint"], [2, 5, 1, "_CPPv4N5cudaq8kraus_op4dataE", "cudaq::kraus_op::data"], [2, 3, 1, "_CPPv4I0EN5cudaq8kraus_op8kraus_opERRNSt16initializer_listI1TEE", "cudaq::kraus_op::kraus_op"], [2, 3, 1, "_CPPv4N5cudaq8kraus_op8kraus_opENSt6vectorIN5cudaq7complexEEE", "cudaq::kraus_op::kraus_op"], [2, 3, 1, "_CPPv4N5cudaq8kraus_op8kraus_opERK8kraus_op", "cudaq::kraus_op::kraus_op"], [2, 2, 1, "_CPPv4I0EN5cudaq8kraus_op8kraus_opERRNSt16initializer_listI1TEE", "cudaq::kraus_op::kraus_op::T"], [2, 4, 1, "_CPPv4N5cudaq8kraus_op8kraus_opENSt6vectorIN5cudaq7complexEEE", "cudaq::kraus_op::kraus_op::d"], [2, 4, 1, "_CPPv4I0EN5cudaq8kraus_op8kraus_opERRNSt16initializer_listI1TEE", "cudaq::kraus_op::kraus_op::initList"], [2, 5, 1, "_CPPv4N5cudaq8kraus_op5nColsE", "cudaq::kraus_op::nCols"], [2, 5, 1, "_CPPv4N5cudaq8kraus_op5nRowsE", "cudaq::kraus_op::nRows"], [2, 3, 1, "_CPPv4N5cudaq8kraus_opaSERK8kraus_op", "cudaq::kraus_op::operator="], [2, 4, 1, "_CPPv4N5cudaq8kraus_opaSERK8kraus_op", "cudaq::kraus_op::operator=::other"], [2, 0, 1, "_CPPv4N5cudaq3mpiE", "cudaq::mpi"], [2, 3, 1, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIdEERKNSt6vectorIdEE", "cudaq::mpi::all_gather"], [2, 3, 1, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIiEERKNSt6vectorIiEE", "cudaq::mpi::all_gather"], [2, 4, 1, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIdEERKNSt6vectorIdEE", "cudaq::mpi::all_gather::global"], [2, 4, 1, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIiEERKNSt6vectorIiEE", "cudaq::mpi::all_gather::global"], [2, 4, 1, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIdEERKNSt6vectorIdEE", "cudaq::mpi::all_gather::local"], [2, 4, 1, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIiEERKNSt6vectorIiEE", "cudaq::mpi::all_gather::local"], [2, 3, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK14BinaryFunction", "cudaq::mpi::all_reduce"], [2, 3, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK4Func", "cudaq::mpi::all_reduce"], [2, 2, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK14BinaryFunction", "cudaq::mpi::all_reduce::BinaryFunction"], [2, 2, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK4Func", "cudaq::mpi::all_reduce::Func"], [2, 2, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK14BinaryFunction", "cudaq::mpi::all_reduce::T"], [2, 2, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK4Func", "cudaq::mpi::all_reduce::T"], [2, 4, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK14BinaryFunction", "cudaq::mpi::all_reduce::function"], [2, 4, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK14BinaryFunction", "cudaq::mpi::all_reduce::localValue"], [2, 3, 1, "_CPPv4N5cudaq3mpi9broadcastERNSt6stringEi", "cudaq::mpi::broadcast"], [2, 3, 1, "_CPPv4N5cudaq3mpi9broadcastERNSt6vectorIdEEi", "cudaq::mpi::broadcast"], [2, 4, 1, "_CPPv4N5cudaq3mpi9broadcastERNSt6stringEi", "cudaq::mpi::broadcast::data"], [2, 4, 1, "_CPPv4N5cudaq3mpi9broadcastERNSt6vectorIdEEi", "cudaq::mpi::broadcast::data"], [2, 4, 1, "_CPPv4N5cudaq3mpi9broadcastERNSt6stringEi", "cudaq::mpi::broadcast::rootRank"], [2, 4, 1, "_CPPv4N5cudaq3mpi9broadcastERNSt6vectorIdEEi", "cudaq::mpi::broadcast::rootRank"], [2, 3, 1, "_CPPv4N5cudaq3mpi8finalizeEv", "cudaq::mpi::finalize"], [2, 3, 1, "_CPPv4N5cudaq3mpi10initializeEiPPc", "cudaq::mpi::initialize"], [2, 3, 1, "_CPPv4N5cudaq3mpi10initializeEv", "cudaq::mpi::initialize"], [2, 4, 1, "_CPPv4N5cudaq3mpi10initializeEiPPc", "cudaq::mpi::initialize::argc"], [2, 4, 1, "_CPPv4N5cudaq3mpi10initializeEiPPc", "cudaq::mpi::initialize::argv"], [2, 3, 1, "_CPPv4N5cudaq3mpi14is_initializedEv", "cudaq::mpi::is_initialized"], [2, 3, 1, "_CPPv4N5cudaq3mpi9num_ranksEv", "cudaq::mpi::num_ranks"], [2, 3, 1, "_CPPv4N5cudaq3mpi4rankEv", "cudaq::mpi::rank"], [2, 1, 1, "_CPPv4N5cudaq11noise_modelE", "cudaq::noise_model"], [2, 3, 1, "_CPPv4IDpEN5cudaq11noise_model11add_channelEvRKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel"], [2, 3, 1, "_CPPv4N5cudaq11noise_model11add_channelERKNSt6stringERKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel"], [2, 2, 1, "_CPPv4IDpEN5cudaq11noise_model11add_channelEvRKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel::QuantumOp"], [2, 4, 1, "_CPPv4IDpEN5cudaq11noise_model11add_channelEvRKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel::channel"], [2, 4, 1, "_CPPv4N5cudaq11noise_model11add_channelERKNSt6stringERKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel::channel"], [2, 4, 1, "_CPPv4N5cudaq11noise_model11add_channelERKNSt6stringERKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel::quantumOp"], [2, 4, 1, "_CPPv4IDpEN5cudaq11noise_model11add_channelEvRKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel::qubits"], [2, 4, 1, "_CPPv4N5cudaq11noise_model11add_channelERKNSt6stringERKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel::qubits"], [2, 3, 1, "_CPPv4NK5cudaq11noise_model5emptyEv", "cudaq::noise_model::empty"], [2, 3, 1, "_CPPv4I0ENK5cudaq11noise_model12get_channelsENSt6vectorI13kraus_channelEERKNSt6vectorINSt6size_tEEE", "cudaq::noise_model::get_channels"], [2, 3, 1, "_CPPv4NK5cudaq11noise_model12get_channelsERKNSt6stringERKNSt6vectorINSt6size_tEEE", "cudaq::noise_model::get_channels"], [2, 2, 1, "_CPPv4I0ENK5cudaq11noise_model12get_channelsENSt6vectorI13kraus_channelEERKNSt6vectorINSt6size_tEEE", "cudaq::noise_model::get_channels::QuantumOp"], [2, 4, 1, "_CPPv4NK5cudaq11noise_model12get_channelsERKNSt6stringERKNSt6vectorINSt6size_tEEE", "cudaq::noise_model::get_channels::quantumOp"], [2, 4, 1, "_CPPv4I0ENK5cudaq11noise_model12get_channelsENSt6vectorI13kraus_channelEERKNSt6vectorINSt6size_tEEE", "cudaq::noise_model::get_channels::qubits"], [2, 4, 1, "_CPPv4NK5cudaq11noise_model12get_channelsERKNSt6stringERKNSt6vectorINSt6size_tEEE", "cudaq::noise_model::get_channels::qubits"], [2, 3, 1, "_CPPv4N5cudaq11noise_model11noise_modelEv", "cudaq::noise_model::noise_model"], [2, 3, 1, "_CPPv4N5cudaq18num_available_gpusEv", "cudaq::num_available_gpus"], [2, 1, 1, "_CPPv4N5cudaq14observe_resultE", "cudaq::observe_result"], [2, 3, 1, "_CPPv4I0EN5cudaq14observe_result6countsE13sample_result10SpinOpType", "cudaq::observe_result::counts"], [2, 2, 1, "_CPPv4I0EN5cudaq14observe_result6countsE13sample_result10SpinOpType", "cudaq::observe_result::counts::SpinOpType"], [2, 4, 1, "_CPPv4I0EN5cudaq14observe_result6countsE13sample_result10SpinOpType", "cudaq::observe_result::counts::term"], [2, 3, 1, "_CPPv4N5cudaq14observe_result4dumpEv", "cudaq::observe_result::dump"], [2, 3, 1, "_CPPv4I0EN5cudaq14observe_result11expectationEd10SpinOpType", "cudaq::observe_result::expectation"], [2, 3, 1, "_CPPv4N5cudaq14observe_result11expectationEv", "cudaq::observe_result::expectation"], [2, 2, 1, "_CPPv4I0EN5cudaq14observe_result11expectationEd10SpinOpType", "cudaq::observe_result::expectation::SpinOpType"], [2, 4, 1, "_CPPv4I0EN5cudaq14observe_result11expectationEd10SpinOpType", "cudaq::observe_result::expectation::term"], [2, 3, 1, "_CPPv4N5cudaq14observe_result14id_coefficientEv", "cudaq::observe_result::id_coefficient"], [2, 3, 1, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op", "cudaq::observe_result::observe_result"], [2, 3, 1, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op13sample_result", "cudaq::observe_result::observe_result"], [2, 4, 1, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op", "cudaq::observe_result::observe_result::H"], [2, 4, 1, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op13sample_result", "cudaq::observe_result::observe_result::H"], [2, 4, 1, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op13sample_result", "cudaq::observe_result::observe_result::counts"], [2, 4, 1, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op", "cudaq::observe_result::observe_result::e"], [2, 4, 1, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op13sample_result", "cudaq::observe_result::observe_result::e"], [2, 3, 1, "_CPPv4N5cudaq14observe_resultcvdEv", "cudaq::observe_result::operator double"], [2, 3, 1, "_CPPv4N5cudaq14observe_result8raw_dataEv", "cudaq::observe_result::raw_data"], [2, 1, 1, "_CPPv4N5cudaq20optimizable_functionE", "cudaq::optimizable_function"], [2, 0, 1, "_CPPv4N5cudaq19optimization_resultE", "cudaq::optimization_result"], [2, 1, 1, "_CPPv4N5cudaq9optimizerE", "cudaq::optimizer"], [2, 3, 1, "_CPPv4N5cudaq9optimizer8optimizeEKiRR20optimizable_function", "cudaq::optimizer::optimize"], [2, 4, 1, "_CPPv4N5cudaq9optimizer8optimizeEKiRR20optimizable_function", "cudaq::optimizer::optimize::dim"], [2, 4, 1, "_CPPv4N5cudaq9optimizer8optimizeEKiRR20optimizable_function", "cudaq::optimizer::optimize::opt_function"], [2, 3, 1, "_CPPv4N5cudaq9optimizer17requiresGradientsEv", "cudaq::optimizer::requiresGradients"], [2, 1, 1, "_CPPv4N5cudaq18phase_flip_channelE", "cudaq::phase_flip_channel"], [2, 1, 1, "_CPPv4I_NSt6size_tE_NSt6size_tE0EN5cudaq4qregE", "cudaq::qreg"], [2, 2, 1, "_CPPv4I_NSt6size_tE_NSt6size_tE0EN5cudaq4qregE", "cudaq::qreg::Levels"], [2, 2, 1, "_CPPv4I_NSt6size_tE_NSt6size_tE0EN5cudaq4qregE", "cudaq::qreg::N"], [2, 3, 1, "_CPPv4N5cudaq4qreg4backENSt6size_tE", "cudaq::qreg::back"], [2, 3, 1, "_CPPv4N5cudaq4qreg4backEv", "cudaq::qreg::back"], [2, 4, 1, "_CPPv4N5cudaq4qreg4backENSt6size_tE", "cudaq::qreg::back::count"], [2, 3, 1, "_CPPv4N5cudaq4qreg5beginEv", "cudaq::qreg::begin"], [2, 3, 1, "_CPPv4N5cudaq4qreg5clearEv", "cudaq::qreg::clear"], [2, 3, 1, "_CPPv4N5cudaq4qreg5frontENSt6size_tE", "cudaq::qreg::front"], [2, 3, 1, "_CPPv4N5cudaq4qreg5frontEv", "cudaq::qreg::front"], [2, 4, 1, "_CPPv4N5cudaq4qreg5frontENSt6size_tE", "cudaq::qreg::front::count"], [2, 3, 1, "_CPPv4N5cudaq4qregixEKNSt6size_tE", "cudaq::qreg::operator[]"], [2, 4, 1, "_CPPv4N5cudaq4qregixEKNSt6size_tE", "cudaq::qreg::operator[]::idx"], [2, 3, 1, "_CPPv4NK5cudaq4qreg4sizeEv", "cudaq::qreg::size"], [2, 3, 1, "_CPPv4N5cudaq4qreg5sliceENSt6size_tENSt6size_tE", "cudaq::qreg::slice"], [2, 4, 1, "_CPPv4N5cudaq4qreg5sliceENSt6size_tENSt6size_tE", "cudaq::qreg::slice::size"], [2, 4, 1, "_CPPv4N5cudaq4qreg5sliceENSt6size_tENSt6size_tE", "cudaq::qreg::slice::start"], [2, 0, 1, "_CPPv4N5cudaq4qreg10value_typeE", "cudaq::qreg::value_type"], [2, 1, 1, "_CPPv4I_NSt6size_tE_NSt6size_tEEN5cudaq5qspanE", "cudaq::qspan"], [2, 2, 1, "_CPPv4I_NSt6size_tE_NSt6size_tEEN5cudaq5qspanE", "cudaq::qspan::Levels"], [2, 2, 1, "_CPPv4I_NSt6size_tE_NSt6size_tEEN5cudaq5qspanE", "cudaq::qspan::N"], [2, 1, 1, "_CPPv4N5cudaq16quantum_platformE", "cudaq::quantum_platform"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform11clear_shotsEv", "cudaq::quantum_platform::clear_shots"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform12connectivityEv", "cudaq::quantum_platform::connectivity"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tER19KernelExecutionTask", "cudaq::quantum_platform::enqueueAsyncTask"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tERNSt8functionIFvvEEE", "cudaq::quantum_platform::enqueueAsyncTask"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tERNSt8functionIFvvEEE", "cudaq::quantum_platform::enqueueAsyncTask::f"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tER19KernelExecutionTask", "cudaq::quantum_platform::enqueueAsyncTask::qpu_id"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tERNSt8functionIFvvEEE", "cudaq::quantum_platform::enqueueAsyncTask::qpu_id"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tER19KernelExecutionTask", "cudaq::quantum_platform::enqueueAsyncTask::t"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform12getLogStreamEv", "cudaq::quantum_platform::getLogStream"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform15get_current_qpuEv", "cudaq::quantum_platform::get_current_qpu"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform12get_exec_ctxEv", "cudaq::quantum_platform::get_exec_ctx"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform14get_num_qubitsENSt6size_tE", "cudaq::quantum_platform::get_num_qubits"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform14get_num_qubitsEv", "cudaq::quantum_platform::get_num_qubits"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform14get_num_qubitsENSt6size_tE", "cudaq::quantum_platform::get_num_qubits::qpu_id"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform23get_remote_capabilitiesEKNSt6size_tE", "cudaq::quantum_platform::get_remote_capabilities"], [2, 4, 1, "_CPPv4NK5cudaq16quantum_platform23get_remote_capabilitiesEKNSt6size_tE", "cudaq::quantum_platform::get_remote_capabilities::qpuId"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform9get_shotsEv", "cudaq::quantum_platform::get_shots"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform11is_emulatedEKNSt6size_tE", "cudaq::quantum_platform::is_emulated"], [2, 4, 1, "_CPPv4NK5cudaq16quantum_platform11is_emulatedEKNSt6size_tE", "cudaq::quantum_platform::is_emulated::qpuId"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform9is_remoteEKNSt6size_tE", "cudaq::quantum_platform::is_remote"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9is_remoteEKNSt6size_tE", "cudaq::quantum_platform::is_remote::qpuId"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform12is_simulatorEKNSt6size_tE", "cudaq::quantum_platform::is_simulator"], [2, 4, 1, "_CPPv4NK5cudaq16quantum_platform12is_simulatorEKNSt6size_tE", "cudaq::quantum_platform::is_simulator::qpu_id"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE::H"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE::gradient"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE::kernelArgs"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE::kernelName"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE::n_params"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE::optimizer"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE::shots"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform14list_platformsEv", "cudaq::quantum_platform::list_platforms"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform4nameEv", "cudaq::quantum_platform::name"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform8num_qpusEv", "cudaq::quantum_platform::num_qpus"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform15onRandomSeedSetENSt6size_tE", "cudaq::quantum_platform::onRandomSeedSet"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform15onRandomSeedSetENSt6size_tE", "cudaq::quantum_platform::onRandomSeedSet::seed"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform14resetLogStreamEv", "cudaq::quantum_platform::resetLogStream"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform14reset_exec_ctxENSt6size_tE", "cudaq::quantum_platform::reset_exec_ctx"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform14reset_exec_ctxENSt6size_tE", "cudaq::quantum_platform::reset_exec_ctx::qpu_id"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform11reset_noiseEv", "cudaq::quantum_platform::reset_noise"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform12setLogStreamERNSt7ostreamE", "cudaq::quantum_platform::setLogStream"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform12setLogStreamERNSt7ostreamE", "cudaq::quantum_platform::setLogStream::logStream"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform16setTargetBackendERKNSt6stringE", "cudaq::quantum_platform::setTargetBackend"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform16setTargetBackendERKNSt6stringE", "cudaq::quantum_platform::setTargetBackend::name"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform15set_current_qpuEKNSt6size_tE", "cudaq::quantum_platform::set_current_qpu"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform15set_current_qpuEKNSt6size_tE", "cudaq::quantum_platform::set_current_qpu::device_id"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform12set_exec_ctxEPN5cudaq16ExecutionContextENSt6size_tE", "cudaq::quantum_platform::set_exec_ctx"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform12set_exec_ctxEPN5cudaq16ExecutionContextENSt6size_tE", "cudaq::quantum_platform::set_exec_ctx::ctx"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform12set_exec_ctxEPN5cudaq16ExecutionContextENSt6size_tE", "cudaq::quantum_platform::set_exec_ctx::qpu_id"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform9set_noiseEPK11noise_model", "cudaq::quantum_platform::set_noise"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9set_noiseEPK11noise_model", "cudaq::quantum_platform::set_noise::model"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform9set_shotsEi", "cudaq::quantum_platform::set_shots"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9set_shotsEi", "cudaq::quantum_platform::set_shots::numShots"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform29supports_conditional_feedbackEKNSt6size_tE", "cudaq::quantum_platform::supports_conditional_feedback"], [2, 4, 1, "_CPPv4NK5cudaq16quantum_platform29supports_conditional_feedbackEKNSt6size_tE", "cudaq::quantum_platform::supports_conditional_feedback::qpu_id"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform26supports_task_distributionEv", "cudaq::quantum_platform::supports_task_distribution"], [2, 0, 1, "_CPPv4N5cudaq5qubitE", "cudaq::qubit"], [2, 1, 1, "_CPPv4I_NSt6size_tEEN5cudaq5quditE", "cudaq::qudit"], [2, 2, 1, "_CPPv4I_NSt6size_tEEN5cudaq5quditE", "cudaq::qudit::Levels"], [2, 3, 1, "_CPPv4N5cudaq5qudit5quditEv", "cudaq::qudit::qudit"], [2, 1, 1, "_CPPv4I_NSt6size_tEEN5cudaq7qvectorE", "cudaq::qvector"], [2, 2, 1, "_CPPv4I_NSt6size_tEEN5cudaq7qvectorE", "cudaq::qvector::Levels"], [2, 3, 1, "_CPPv4N5cudaq7qvector4backENSt6size_tE", "cudaq::qvector::back"], [2, 3, 1, "_CPPv4N5cudaq7qvector4backEv", "cudaq::qvector::back"], [2, 4, 1, "_CPPv4N5cudaq7qvector4backENSt6size_tE", "cudaq::qvector::back::count"], [2, 3, 1, "_CPPv4N5cudaq7qvector5beginEv", "cudaq::qvector::begin"], [2, 3, 1, "_CPPv4N5cudaq7qvector5clearEv", "cudaq::qvector::clear"], [2, 3, 1, "_CPPv4N5cudaq7qvector3endEv", "cudaq::qvector::end"], [2, 3, 1, "_CPPv4N5cudaq7qvector5frontENSt6size_tE", "cudaq::qvector::front"], [2, 3, 1, "_CPPv4N5cudaq7qvector5frontEv", "cudaq::qvector::front"], [2, 4, 1, "_CPPv4N5cudaq7qvector5frontENSt6size_tE", "cudaq::qvector::front::count"], [2, 3, 1, "_CPPv4N5cudaq7qvectoraSERK7qvector", "cudaq::qvector::operator="], [2, 3, 1, "_CPPv4N5cudaq7qvectorixEKNSt6size_tE", "cudaq::qvector::operator[]"], [2, 4, 1, "_CPPv4N5cudaq7qvectorixEKNSt6size_tE", "cudaq::qvector::operator[]::idx"], [2, 3, 1, "_CPPv4N5cudaq7qvector7qvectorENSt6size_tE", "cudaq::qvector::qvector"], [2, 3, 1, "_CPPv4N5cudaq7qvector7qvectorERK5state", "cudaq::qvector::qvector"], [2, 3, 1, "_CPPv4N5cudaq7qvector7qvectorERK7qvector", "cudaq::qvector::qvector"], [2, 3, 1, "_CPPv4N5cudaq7qvector7qvectorERKNSt6vectorI7complexEEb", "cudaq::qvector::qvector"], [2, 3, 1, "_CPPv4N5cudaq7qvector7qvectorERR7qvector", "cudaq::qvector::qvector"], [2, 4, 1, "_CPPv4N5cudaq7qvector7qvectorENSt6size_tE", "cudaq::qvector::qvector::size"], [2, 4, 1, "_CPPv4N5cudaq7qvector7qvectorERK5state", "cudaq::qvector::qvector::state"], [2, 4, 1, "_CPPv4N5cudaq7qvector7qvectorERKNSt6vectorI7complexEEb", "cudaq::qvector::qvector::validate"], [2, 4, 1, "_CPPv4N5cudaq7qvector7qvectorERKNSt6vectorI7complexEEb", "cudaq::qvector::qvector::vector"], [2, 3, 1, "_CPPv4NK5cudaq7qvector4sizeEv", "cudaq::qvector::size"], [2, 3, 1, "_CPPv4N5cudaq7qvector5sliceENSt6size_tENSt6size_tE", "cudaq::qvector::slice"], [2, 4, 1, "_CPPv4N5cudaq7qvector5sliceENSt6size_tENSt6size_tE", "cudaq::qvector::slice::size"], [2, 4, 1, "_CPPv4N5cudaq7qvector5sliceENSt6size_tENSt6size_tE", "cudaq::qvector::slice::start"], [2, 0, 1, "_CPPv4N5cudaq7qvector10value_typeE", "cudaq::qvector::value_type"], [2, 1, 1, "_CPPv4I_NSt6size_tEEN5cudaq5qviewE", "cudaq::qview"], [2, 2, 1, "_CPPv4I_NSt6size_tEEN5cudaq5qviewE", "cudaq::qview::Levels"], [2, 0, 1, "_CPPv4N5cudaq5qview10value_typeE", "cudaq::qview::value_type"], [2, 3, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType", "cudaq::range"], [2, 3, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType11ElementType11ElementType", "cudaq::range"], [2, 3, 1, "_CPPv4N5cudaq5rangeENSt6size_tE", "cudaq::range"], [2, 2, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType", "cudaq::range::ElementType"], [2, 2, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType11ElementType11ElementType", "cudaq::range::ElementType"], [2, 4, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType", "cudaq::range::N"], [2, 4, 1, "_CPPv4N5cudaq5rangeENSt6size_tE", "cudaq::range::N"], [2, 4, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType11ElementType11ElementType", "cudaq::range::start"], [2, 4, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType11ElementType11ElementType", "cudaq::range::step"], [2, 4, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType11ElementType11ElementType", "cudaq::range::stop"], [2, 0, 1, "_CPPv4N5cudaq4realE", "cudaq::real"], [2, 0, 1, "_CPPv4N5cudaq8registryE", "cudaq::registry"], [2, 1, 1, "_CPPv4I0EN5cudaq8registry14RegisteredTypeE", "cudaq::registry::RegisteredType"], [2, 2, 1, "_CPPv4I0EN5cudaq8registry14RegisteredTypeE", "cudaq::registry::RegisteredType::T"], [2, 1, 1, "_CPPv4N5cudaq13sample_resultE", "cudaq::sample_result"], [2, 3, 1, "_CPPv4N5cudaq13sample_result6appendER15ExecutionResult", "cudaq::sample_result::append"], [2, 4, 1, "_CPPv4N5cudaq13sample_result6appendER15ExecutionResult", "cudaq::sample_result::append::result"], [2, 3, 1, "_CPPv4N5cudaq13sample_result5beginEv", "cudaq::sample_result::begin"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result5beginEv", "cudaq::sample_result::begin"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result6cbeginEv", "cudaq::sample_result::cbegin"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result4cendEv", "cudaq::sample_result::cend"], [2, 3, 1, "_CPPv4N5cudaq13sample_result5clearEv", "cudaq::sample_result::clear"], [2, 3, 1, "_CPPv4N5cudaq13sample_result5countENSt11string_viewEKNSt11string_viewE", "cudaq::sample_result::count"], [2, 4, 1, "_CPPv4N5cudaq13sample_result5countENSt11string_viewEKNSt11string_viewE", "cudaq::sample_result::count::bitString"], [2, 4, 1, "_CPPv4N5cudaq13sample_result5countENSt11string_viewEKNSt11string_viewE", "cudaq::sample_result::count::registerName"], [2, 3, 1, "_CPPv4N5cudaq13sample_result11deserializeERNSt6vectorINSt6size_tEEE", "cudaq::sample_result::deserialize"], [2, 4, 1, "_CPPv4N5cudaq13sample_result11deserializeERNSt6vectorINSt6size_tEEE", "cudaq::sample_result::deserialize::data"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result4dumpERNSt7ostreamE", "cudaq::sample_result::dump"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result4dumpEv", "cudaq::sample_result::dump"], [2, 4, 1, "_CPPv4NK5cudaq13sample_result4dumpERNSt7ostreamE", "cudaq::sample_result::dump::os"], [2, 3, 1, "_CPPv4N5cudaq13sample_result3endEv", "cudaq::sample_result::end"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result3endEv", "cudaq::sample_result::end"], [2, 3, 1, "_CPPv4N5cudaq13sample_result9exp_val_zEKNSt11string_viewE", "cudaq::sample_result::exp_val_z"], [2, 4, 1, "_CPPv4N5cudaq13sample_result9exp_val_zEKNSt11string_viewE", "cudaq::sample_result::exp_val_z::registerName"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result11expectationEKNSt11string_viewE", "cudaq::sample_result::expectation"], [2, 4, 1, "_CPPv4NK5cudaq13sample_result11expectationEKNSt11string_viewE", "cudaq::sample_result::expectation::registerName"], [2, 3, 1, "_CPPv4N5cudaq13sample_result12get_marginalERKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::get_marginal"], [2, 3, 1, "_CPPv4N5cudaq13sample_result12get_marginalERRKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::get_marginal"], [2, 4, 1, "_CPPv4N5cudaq13sample_result12get_marginalERKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::get_marginal::marginalIndices"], [2, 4, 1, "_CPPv4N5cudaq13sample_result12get_marginalERRKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::get_marginal::marginalIndices"], [2, 4, 1, "_CPPv4N5cudaq13sample_result12get_marginalERKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::get_marginal::registerName"], [2, 4, 1, "_CPPv4N5cudaq13sample_result12get_marginalERRKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::get_marginal::registerName"], [2, 3, 1, "_CPPv4N5cudaq13sample_result15has_even_parityENSt11string_viewE", "cudaq::sample_result::has_even_parity"], [2, 4, 1, "_CPPv4N5cudaq13sample_result15has_even_parityENSt11string_viewE", "cudaq::sample_result::has_even_parity::bitString"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result15has_expectationEKNSt11string_viewE", "cudaq::sample_result::has_expectation"], [2, 4, 1, "_CPPv4NK5cudaq13sample_result15has_expectationEKNSt11string_viewE", "cudaq::sample_result::has_expectation::registerName"], [2, 3, 1, "_CPPv4N5cudaq13sample_result13most_probableEKNSt11string_viewE", "cudaq::sample_result::most_probable"], [2, 4, 1, "_CPPv4N5cudaq13sample_result13most_probableEKNSt11string_viewE", "cudaq::sample_result::most_probable::registerName"], [2, 3, 1, "_CPPv4N5cudaq13sample_resultpLERK13sample_result", "cudaq::sample_result::operator+="], [2, 4, 1, "_CPPv4N5cudaq13sample_resultpLERK13sample_result", "cudaq::sample_result::operator+=::other"], [2, 3, 1, "_CPPv4N5cudaq13sample_resultaSER13sample_result", "cudaq::sample_result::operator="], [2, 4, 1, "_CPPv4N5cudaq13sample_resultaSER13sample_result", "cudaq::sample_result::operator=::counts"], [2, 3, 1, "_CPPv4NK5cudaq13sample_resulteqERK13sample_result", "cudaq::sample_result::operator=="], [2, 4, 1, "_CPPv4NK5cudaq13sample_resulteqERK13sample_result", "cudaq::sample_result::operator==::counts"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result11probabilityENSt11string_viewEKNSt11string_viewE", "cudaq::sample_result::probability"], [2, 4, 1, "_CPPv4NK5cudaq13sample_result11probabilityENSt11string_viewEKNSt11string_viewE", "cudaq::sample_result::probability::bitString"], [2, 4, 1, "_CPPv4NK5cudaq13sample_result11probabilityENSt11string_viewEKNSt11string_viewE", "cudaq::sample_result::probability::registerName"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result14register_namesEv", "cudaq::sample_result::register_names"], [2, 3, 1, "_CPPv4N5cudaq13sample_result7reorderERKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::reorder"], [2, 4, 1, "_CPPv4N5cudaq13sample_result7reorderERKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::reorder::index"], [2, 4, 1, "_CPPv4N5cudaq13sample_result7reorderERKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::reorder::registerName"], [2, 3, 1, "_CPPv4N5cudaq13sample_result13sample_resultER15ExecutionResult", "cudaq::sample_result::sample_result"], [2, 3, 1, "_CPPv4N5cudaq13sample_result13sample_resultERK13sample_result", "cudaq::sample_result::sample_result"], [2, 3, 1, "_CPPv4N5cudaq13sample_result13sample_resultERNSt6vectorI15ExecutionResultEE", "cudaq::sample_result::sample_result"], [2, 3, 1, "_CPPv4N5cudaq13sample_result13sample_resultERR15ExecutionResult", "cudaq::sample_result::sample_result"], [2, 3, 1, "_CPPv4N5cudaq13sample_result13sample_resultEdRNSt6vectorI15ExecutionResultEE", "cudaq::sample_result::sample_result"], [2, 3, 1, "_CPPv4N5cudaq13sample_result13sample_resultEv", "cudaq::sample_result::sample_result"], [2, 4, 1, "_CPPv4N5cudaq13sample_result13sample_resultEdRNSt6vectorI15ExecutionResultEE", "cudaq::sample_result::sample_result::preComputedExp"], [2, 4, 1, "_CPPv4N5cudaq13sample_result13sample_resultER15ExecutionResult", "cudaq::sample_result::sample_result::result"], [2, 4, 1, "_CPPv4N5cudaq13sample_result13sample_resultERR15ExecutionResult", "cudaq::sample_result::sample_result::result"], [2, 4, 1, "_CPPv4N5cudaq13sample_result13sample_resultERNSt6vectorI15ExecutionResultEE", "cudaq::sample_result::sample_result::results"], [2, 4, 1, "_CPPv4N5cudaq13sample_result13sample_resultEdRNSt6vectorI15ExecutionResultEE", "cudaq::sample_result::sample_result::results"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result9serializeEv", "cudaq::sample_result::serialize"], [2, 3, 1, "_CPPv4N5cudaq13sample_result4sizeEKNSt11string_viewE", "cudaq::sample_result::size"], [2, 4, 1, "_CPPv4N5cudaq13sample_result4sizeEKNSt11string_viewE", "cudaq::sample_result::size::registerName"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result6to_mapEKNSt11string_viewE", "cudaq::sample_result::to_map"], [2, 4, 1, "_CPPv4NK5cudaq13sample_result6to_mapEKNSt11string_viewE", "cudaq::sample_result::to_map::registerName"], [2, 3, 1, "_CPPv4N5cudaq13sample_resultD0Ev", "cudaq::sample_result::~sample_result"], [2, 3, 1, "_CPPv4N5cudaq9set_noiseERKN5cudaq11noise_modelE", "cudaq::set_noise"], [2, 4, 1, "_CPPv4N5cudaq9set_noiseERKN5cudaq11noise_modelE", "cudaq::set_noise::model"], [2, 3, 1, "_CPPv4N5cudaq15set_random_seedENSt6size_tE", "cudaq::set_random_seed"], [2, 4, 1, "_CPPv4N5cudaq15set_random_seedENSt6size_tE", "cudaq::set_random_seed::seed"], [2, 6, 1, "_CPPv4N5cudaq20simulation_precisionE", "cudaq::simulation_precision"], [2, 7, 1, "_CPPv4N5cudaq20simulation_precision4fp32E", "cudaq::simulation_precision::fp32"], [2, 7, 1, "_CPPv4N5cudaq20simulation_precision4fp64E", "cudaq::simulation_precision::fp64"], [2, 1, 1, "_CPPv4N5cudaq7spin_opE", "cudaq::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op5beginEv", "cudaq::spin_op::begin"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op5beginEv", "cudaq::spin_op::begin"], [2, 0, 1, "_CPPv4N5cudaq7spin_op12csr_spmatrixE", "cudaq::spin_op::csr_spmatrix"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op16distribute_termsENSt6size_tE", "cudaq::spin_op::distribute_terms"], [2, 4, 1, "_CPPv4NK5cudaq7spin_op16distribute_termsENSt6size_tE", "cudaq::spin_op::distribute_terms::numChunks"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op4dumpEv", "cudaq::spin_op::dump"], [2, 3, 1, "_CPPv4N5cudaq7spin_op3endEv", "cudaq::spin_op::end"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op3endEv", "cudaq::spin_op::end"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op14for_each_pauliERRNSt8functionIFv5pauliNSt6size_tEEEE", "cudaq::spin_op::for_each_pauli"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op13for_each_termERRNSt8functionIFvR7spin_opEEE", "cudaq::spin_op::for_each_term"], [2, 3, 1, "_CPPv4N5cudaq7spin_op9from_wordERKNSt6stringE", "cudaq::spin_op::from_word"], [2, 4, 1, "_CPPv4N5cudaq7spin_op9from_wordERKNSt6stringE", "cudaq::spin_op::from_word::pauliWord"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op21getDataRepresentationEv", "cudaq::spin_op::getDataRepresentation"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op12getDataTupleEv", "cudaq::spin_op::getDataTuple"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op15get_coefficientEv", "cudaq::spin_op::get_coefficient"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op12get_raw_dataEv", "cudaq::spin_op::get_raw_data"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op11is_identityEv", "cudaq::spin_op::is_identity"], [2, 1, 1, "_CPPv4I0EN5cudaq7spin_op8iteratorE", "cudaq::spin_op::iterator"], [2, 2, 1, "_CPPv4I0EN5cudaq7spin_op8iteratorE", "cudaq::spin_op::iterator::QualifiedSpinOp"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op10num_qubitsEv", "cudaq::spin_op::num_qubits"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op9num_termsEv", "cudaq::spin_op::num_terms"], [2, 3, 1, "_CPPv4N5cudaq7spin_opmLEKNSt7complexIdEE", "cudaq::spin_op::operator*="], [2, 3, 1, "_CPPv4N5cudaq7spin_opmLEKd", "cudaq::spin_op::operator*="], [2, 3, 1, "_CPPv4N5cudaq7spin_opmLERK7spin_op", "cudaq::spin_op::operator*="], [2, 4, 1, "_CPPv4N5cudaq7spin_opmLEKNSt7complexIdEE", "cudaq::spin_op::operator*=::v"], [2, 4, 1, "_CPPv4N5cudaq7spin_opmLEKd", "cudaq::spin_op::operator*=::v"], [2, 4, 1, "_CPPv4N5cudaq7spin_opmLERK7spin_op", "cudaq::spin_op::operator*=::v"], [2, 3, 1, "_CPPv4N5cudaq7spin_oppLERK7spin_op", "cudaq::spin_op::operator+="], [2, 4, 1, "_CPPv4N5cudaq7spin_oppLERK7spin_op", "cudaq::spin_op::operator+=::v"], [2, 3, 1, "_CPPv4N5cudaq7spin_opmIERK7spin_op", "cudaq::spin_op::operator-="], [2, 4, 1, "_CPPv4N5cudaq7spin_opmIERK7spin_op", "cudaq::spin_op::operator-=::v"], [2, 3, 1, "_CPPv4N5cudaq7spin_opaSERK7spin_op", "cudaq::spin_op::operator="], [2, 3, 1, "_CPPv4NK5cudaq7spin_opeqERK7spin_op", "cudaq::spin_op::operator=="], [2, 4, 1, "_CPPv4NK5cudaq7spin_opeqERK7spin_op", "cudaq::spin_op::operator==::v"], [2, 3, 1, "_CPPv4N5cudaq7spin_op6randomENSt6size_tENSt6size_tEj", "cudaq::spin_op::random"], [2, 4, 1, "_CPPv4N5cudaq7spin_op6randomENSt6size_tENSt6size_tEj", "cudaq::spin_op::random::nQubits"], [2, 4, 1, "_CPPv4N5cudaq7spin_op6randomENSt6size_tENSt6size_tEj", "cudaq::spin_op::random::nTerms"], [2, 4, 1, "_CPPv4N5cudaq7spin_op6randomENSt6size_tENSt6size_tEj", "cudaq::spin_op::random::seed"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opE5pauliKNSt6size_tENSt7complexIdEE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opENSt6size_tE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opERK12spin_op_termRKNSt7complexIdEE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opERK7spin_op", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt13unordered_mapI12spin_op_termNSt7complexIdEEEE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt4pairIK12spin_op_termNSt7complexIdEEEE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorI12spin_op_termEERKNSt6vectorINSt7complexIdEEEE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorIdEENSt6size_tE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opERNSt4pairIK12spin_op_termNSt7complexIdEEEE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opEv", "cudaq::spin_op::spin_op"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt13unordered_mapI12spin_op_termNSt7complexIdEEEE", "cudaq::spin_op::spin_op::_terms"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorI12spin_op_termEERKNSt6vectorINSt7complexIdEEEE", "cudaq::spin_op::spin_op::bsf"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opE5pauliKNSt6size_tENSt7complexIdEE", "cudaq::spin_op::spin_op::coeff"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERK12spin_op_termRKNSt7complexIdEE", "cudaq::spin_op::spin_op::coeff"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorI12spin_op_termEERKNSt6vectorINSt7complexIdEEEE", "cudaq::spin_op::spin_op::coeffs"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorIdEENSt6size_tE", "cudaq::spin_op::spin_op::data_rep"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opE5pauliKNSt6size_tENSt7complexIdEE", "cudaq::spin_op::spin_op::id"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorIdEENSt6size_tE", "cudaq::spin_op::spin_op::nQubits"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opENSt6size_tE", "cudaq::spin_op::spin_op::numQubits"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERK7spin_op", "cudaq::spin_op::spin_op::o"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERK12spin_op_termRKNSt7complexIdEE", "cudaq::spin_op::spin_op::term"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt4pairIK12spin_op_termNSt7complexIdEEEE", "cudaq::spin_op::spin_op::termData"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERNSt4pairIK12spin_op_termNSt7complexIdEEEE", "cudaq::spin_op::spin_op::termData"], [2, 0, 1, "_CPPv4N5cudaq7spin_op12spin_op_termE", "cudaq::spin_op::spin_op_term"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op9to_matrixEv", "cudaq::spin_op::to_matrix"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op16to_sparse_matrixEv", "cudaq::spin_op::to_sparse_matrix"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op9to_stringEb", "cudaq::spin_op::to_string"], [2, 4, 1, "_CPPv4NK5cudaq7spin_op9to_stringEb", "cudaq::spin_op::to_string::printCoefficients"], [2, 3, 1, "_CPPv4N5cudaq7spin_opD0Ev", "cudaq::spin_op::~spin_op"], [2, 1, 1, "_CPPv4N5cudaq5stateE", "cudaq::state"], [2, 3, 1, "_CPPv4N5cudaq5state9amplitudeERKNSt6vectorIiEE", "cudaq::state::amplitude"], [2, 4, 1, "_CPPv4N5cudaq5state9amplitudeERKNSt6vectorIiEE", "cudaq::state::amplitude::basisState"], [2, 3, 1, "_CPPv4N5cudaq5state10amplitudesERKNSt6vectorINSt6vectorIiEEEE", "cudaq::state::amplitudes"], [2, 4, 1, "_CPPv4N5cudaq5state10amplitudesERKNSt6vectorINSt6vectorIiEEEE", "cudaq::state::amplitudes::basisStates"], [2, 3, 1, "_CPPv4NK5cudaq5state4dumpERNSt7ostreamE", "cudaq::state::dump"], [2, 3, 1, "_CPPv4NK5cudaq5state4dumpEv", "cudaq::state::dump"], [2, 4, 1, "_CPPv4NK5cudaq5state4dumpERNSt7ostreamE", "cudaq::state::dump::os"], [2, 3, 1, "_CPPv4N5cudaq5state9from_dataERK10state_data", "cudaq::state::from_data"], [2, 4, 1, "_CPPv4N5cudaq5state9from_dataERK10state_data", "cudaq::state::from_data::data"], [2, 3, 1, "_CPPv4NK5cudaq5state14get_num_qubitsEv", "cudaq::state::get_num_qubits"], [2, 3, 1, "_CPPv4NK5cudaq5state15get_num_tensorsEv", "cudaq::state::get_num_tensors"], [2, 3, 1, "_CPPv4NK5cudaq5state13get_precisionEv", "cudaq::state::get_precision"], [2, 3, 1, "_CPPv4NK5cudaq5state10get_tensorENSt6size_tE", "cudaq::state::get_tensor"], [2, 4, 1, "_CPPv4NK5cudaq5state10get_tensorENSt6size_tE", "cudaq::state::get_tensor::tensorIdx"], [2, 3, 1, "_CPPv4NK5cudaq5state11get_tensorsEv", "cudaq::state::get_tensors"], [2, 3, 1, "_CPPv4NK5cudaq5state9is_on_gpuEv", "cudaq::state::is_on_gpu"], [2, 3, 1, "_CPPv4N5cudaq5stateclENSt6size_tENSt6size_tE", "cudaq::state::operator()"], [2, 3, 1, "_CPPv4N5cudaq5stateclERKNSt16initializer_listINSt6size_tEEENSt6size_tE", "cudaq::state::operator()"], [2, 4, 1, "_CPPv4N5cudaq5stateclENSt6size_tENSt6size_tE", "cudaq::state::operator()::idx"], [2, 4, 1, "_CPPv4N5cudaq5stateclENSt6size_tENSt6size_tE", "cudaq::state::operator()::jdx"], [2, 4, 1, "_CPPv4N5cudaq5stateclERKNSt16initializer_listINSt6size_tEEENSt6size_tE", "cudaq::state::operator()::tensorIdx"], [2, 3, 1, "_CPPv4N5cudaq5stateaSERR5state", "cudaq::state::operator="], [2, 4, 1, "_CPPv4N5cudaq5stateaSERR5state", "cudaq::state::operator=::other"], [2, 3, 1, "_CPPv4N5cudaq5stateixENSt6size_tE", "cudaq::state::operator[]"], [2, 4, 1, "_CPPv4N5cudaq5stateixENSt6size_tE", "cudaq::state::operator[]::idx"], [2, 3, 1, "_CPPv4N5cudaq5state7overlapERK5state", "cudaq::state::overlap"], [2, 4, 1, "_CPPv4N5cudaq5state7overlapERK5state", "cudaq::state::overlap::other"], [2, 3, 1, "_CPPv4N5cudaq5state5stateEP15SimulationState", "cudaq::state::state"], [2, 3, 1, "_CPPv4N5cudaq5state5stateERK5state", "cudaq::state::state"], [2, 4, 1, "_CPPv4N5cudaq5state5stateERK5state", "cudaq::state::state::other"], [2, 4, 1, "_CPPv4N5cudaq5state5stateEP15SimulationState", "cudaq::state::state::ptrToOwn"], [2, 3, 1, "_CPPv4I0ENK5cudaq5state7to_hostEvPNSt7complexI10ScalarTypeEENSt6size_tE", "cudaq::state::to_host"], [2, 2, 1, "_CPPv4I0ENK5cudaq5state7to_hostEvPNSt7complexI10ScalarTypeEENSt6size_tE", "cudaq::state::to_host::ScalarType"], [2, 4, 1, "_CPPv4I0ENK5cudaq5state7to_hostEvPNSt7complexI10ScalarTypeEENSt6size_tE", "cudaq::state::to_host::hostPtr"], [2, 4, 1, "_CPPv4I0ENK5cudaq5state7to_hostEvPNSt7complexI10ScalarTypeEENSt6size_tE", "cudaq::state::to_host::numElements"], [2, 0, 1, "_CPPv4N5cudaq10state_dataE", "cudaq::state_data"], [2, 0, 1, "_CPPv4N5cudaq6tensorE", "cudaq::tensor"], [2, 3, 1, "_CPPv4N5cudaq11unset_noiseEv", "cudaq::unset_noise"], [2, 1, 1, "_CPPv4N5nvqir18MPSSimulationStateE", "nvqir::MPSSimulationState"], [2, 1, 1, "_CPPv4N5nvqir24TensorNetSimulationStateE", "nvqir::TensorNetSimulationState"], [3, 8, 0, "-", "cudaq"]], "cudaq": [[3, 9, 1, "", "AmplitudeDampingChannel"], [3, 9, 1, "", "AsyncObserveResult"], [3, 9, 1, "", "AsyncSampleResult"], [3, 9, 1, "", "AsyncStateResult"], [3, 9, 1, "", "BitFlipChannel"], [3, 9, 1, "", "ComplexMatrix"], [3, 9, 1, "", "DepolarizationChannel"], [3, 11, 1, "", "Kernel"], [3, 9, 1, "", "KrausChannel"], [3, 9, 1, "", "KrausOperator"], [3, 9, 1, "", "NoiseModel"], [3, 9, 1, "", "ObserveResult"], [3, 9, 1, "", "OptimizationResult"], [3, 9, 1, "", "PhaseFlipChannel"], [3, 9, 1, "", "PyKernel"], [3, 9, 1, "", "PyKernelDecorator"], [3, 9, 1, "", "QuakeValue"], [3, 9, 1, "", "SampleResult"], [3, 9, 1, "", "SimulationPrecision"], [3, 9, 1, "", "SpinOperator"], [3, 9, 1, "", "State"], [3, 9, 1, "", "Target"], [3, 9, 1, "", "Tensor"], [3, 13, 1, "", "draw"], [3, 13, 1, "", "get_state"], [3, 13, 1, "", "get_state_async"], [3, 13, 1, "", "get_target"], [3, 13, 1, "", "get_targets"], [3, 13, 1, "", "has_target"], [3, 10, 1, "", "initialize_cudaq"], [3, 13, 1, "", "kernel"], [3, 13, 1, "", "make_kernel"], [3, 10, 1, "", "num_available_gpus"], [3, 13, 1, "", "observe"], [3, 13, 1, "", "observe_async"], [3, 11, 1, "", "qreg"], [3, 9, 1, "", "qubit"], [3, 9, 1, "", "qvector"], [3, 13, 1, "", "reset_target"], [3, 13, 1, "", "sample"], [3, 13, 1, "", "sample_async"], [3, 13, 1, "", "set_noise"], [3, 10, 1, "", "set_random_seed"], [3, 13, 1, "", "set_target"], [3, 13, 1, "", "translate"], [3, 13, 1, "", "unset_noise"], [3, 13, 1, "", "vqe"]], "cudaq.AmplitudeDampingChannel": [[3, 10, 1, "", "__init__"]], "cudaq.AsyncObserveResult": [[3, 10, 1, "", "get"]], "cudaq.AsyncSampleResult": [[3, 10, 1, "", "get"]], "cudaq.AsyncStateResult": [[3, 10, 1, "", "get"]], "cudaq.BitFlipChannel": [[3, 10, 1, "", "__init__"]], "cudaq.ComplexMatrix": [[3, 10, 1, "", "__getitem__"], [3, 10, 1, "", "__str__"], [3, 10, 1, "", "minimal_eigenvalue"]], "cudaq.DepolarizationChannel": [[3, 10, 1, "", "__init__"]], "cudaq.KrausChannel": [[3, 10, 1, "", "__getitem__"], [3, 10, 1, "", "append"]], "cudaq.KrausOperator": [[3, 12, 1, "", "col_count"], [3, 12, 1, "", "row_count"]], "cudaq.NoiseModel": [[3, 10, 1, "", "__init__"], [3, 10, 1, "", "add_channel"], [3, 10, 1, "", "get_channels"]], "cudaq.ObserveResult": [[3, 10, 1, "", "counts"], [3, 10, 1, "", "dump"], [3, 10, 1, "", "expectation"], [3, 10, 1, "", "expectation_z"], [3, 10, 1, "", "get_spin"]], "cudaq.PhaseFlipChannel": [[3, 10, 1, "", "__init__"]], "cudaq.PyKernel": [[3, 11, 1, "", "argument_count"], [3, 11, 1, "", "arguments"], [3, 11, 1, "", "name"]], "cudaq.PyKernelDecorator": [[3, 10, 1, "", "__call__"], [3, 10, 1, "", "__str__"], [3, 10, 1, "", "compile"], [3, 10, 1, "", "from_json"], [3, 10, 1, "", "to_json"], [3, 10, 1, "", "type_to_str"]], "cudaq.QuakeValue": [[3, 10, 1, "", "__add__"], [3, 10, 1, "", "__getitem__"], [3, 10, 1, "", "__mul__"], [3, 10, 1, "", "__neg__"], [3, 10, 1, "", "__radd__"], [3, 10, 1, "", "__rmul__"], [3, 10, 1, "", "__rsub__"], [3, 10, 1, "", "__sub__"], [3, 10, 1, "", "slice"]], "cudaq.SampleResult": [[3, 10, 1, "", "__getitem__"], [3, 10, 1, "", "__iter__"], [3, 10, 1, "", "__len__"], [3, 10, 1, "", "clear"], [3, 10, 1, "", "count"], [3, 10, 1, "", "dump"], [3, 10, 1, "", "expectation"], [3, 10, 1, "", "expectation_z"], [3, 10, 1, "", "get_marginal_counts"], [3, 10, 1, "", "get_register_counts"], [3, 10, 1, "", "get_sequential_data"], [3, 10, 1, "", "items"], [3, 10, 1, "", "most_probable"], [3, 10, 1, "", "probability"], [3, 11, 1, "", "register_names"], [3, 10, 1, "", "values"]], "cudaq.SimulationPrecision": [[3, 12, 1, "", "name"]], "cudaq.SpinOperator": [[3, 10, 1, "", "__add__"], [3, 10, 1, "", "__eq__"], [3, 10, 1, "", "__iter__"], [3, 10, 1, "", "__mul__"], [3, 10, 1, "", "__radd__"], [3, 10, 1, "", "__rmul__"], [3, 10, 1, "", "__rsub__"], [3, 10, 1, "", "__sub__"], [3, 10, 1, "", "distribute_terms"], [3, 10, 1, "", "dump"], [3, 10, 1, "", "for_each_pauli"], [3, 10, 1, "", "for_each_term"], [3, 10, 1, "", "from_json"], [3, 10, 1, "", "from_word"], [3, 10, 1, "", "get_coefficient"], [3, 10, 1, "", "get_qubit_count"], [3, 10, 1, "", "get_raw_data"], [3, 10, 1, "", "get_term_count"], [3, 10, 1, "", "is_identity"], [3, 10, 1, "", "random"], [3, 10, 1, "", "serialize"], [3, 10, 1, "", "to_json"], [3, 10, 1, "", "to_matrix"], [3, 10, 1, "", "to_sparse_matrix"], [3, 10, 1, "", "to_string"]], "cudaq.State": [[3, 10, 1, "", "amplitude"], [3, 10, 1, "", "amplitudes"], [3, 10, 1, "", "dump"], [3, 10, 1, "", "from_data"], [3, 10, 1, "", "getTensor"], [3, 10, 1, "", "getTensors"], [3, 10, 1, "", "is_on_gpu"], [3, 10, 1, "", "num_qubits"], [3, 10, 1, "", "overlap"]], "cudaq.Target": [[3, 12, 1, "", "description"], [3, 10, 1, "", "get_precision"], [3, 10, 1, "", "is_emulated"], [3, 10, 1, "", "is_remote"], [3, 12, 1, "", "name"], [3, 10, 1, "", "num_qpus"], [3, 12, 1, "", "platform"], [3, 12, 1, "", "simulator"]], "cudaq.gradients": [[3, 9, 1, "", "CentralDifference"], [3, 9, 1, "", "ForwardDifference"], [3, 9, 1, "", "ParameterShift"], [3, 9, 1, "", "gradient"]], "cudaq.gradients.CentralDifference": [[3, 10, 1, "", "compute"], [3, 10, 1, "", "from_json"], [3, 10, 1, "", "to_json"]], "cudaq.gradients.ForwardDifference": [[3, 10, 1, "", "compute"], [3, 10, 1, "", "from_json"], [3, 10, 1, "", "to_json"]], "cudaq.gradients.ParameterShift": [[3, 10, 1, "", "compute"], [3, 10, 1, "", "from_json"], [3, 10, 1, "", "to_json"]], "cudaq.mpi": [[3, 10, 1, "", "all_gather"], [3, 10, 1, "", "broadcast"], [3, 10, 1, "", "finalize"], [3, 10, 1, "", "initialize"], [3, 10, 1, "", "is_initialized"], [3, 10, 1, "", "num_ranks"], [3, 10, 1, "", "rank"]], "cudaq.optimizers": [[3, 9, 1, "", "COBYLA"], [3, 9, 1, "", "GradientDescent"], [3, 9, 1, "", "LBFGS"], [3, 9, 1, "", "NelderMead"], [3, 9, 1, "", "optimizer"]], "cudaq.optimizers.COBYLA": [[3, 10, 1, "", "from_json"], [3, 12, 1, "", "initial_parameters"], [3, 12, 1, "", "lower_bounds"], [3, 12, 1, "", "max_iterations"], [3, 10, 1, "", "optimize"], [3, 10, 1, "", "requires_gradients"], [3, 10, 1, "", "to_json"], [3, 12, 1, "", "upper_bounds"]], "cudaq.optimizers.GradientDescent": [[3, 10, 1, "", "from_json"], [3, 12, 1, "", "initial_parameters"], [3, 12, 1, "", "lower_bounds"], [3, 12, 1, "", "max_iterations"], [3, 10, 1, "", "optimize"], [3, 10, 1, "", "requires_gradients"], [3, 10, 1, "", "to_json"], [3, 12, 1, "", "upper_bounds"]], "cudaq.optimizers.LBFGS": [[3, 10, 1, "", "from_json"], [3, 12, 1, "", "initial_parameters"], [3, 12, 1, "", "lower_bounds"], [3, 12, 1, "", "max_iterations"], [3, 10, 1, "", "optimize"], [3, 10, 1, "", "requires_gradients"], [3, 10, 1, "", "to_json"], [3, 12, 1, "", "upper_bounds"]], "cudaq.optimizers.NelderMead": [[3, 10, 1, "", "from_json"], [3, 12, 1, "", "initial_parameters"], [3, 12, 1, "", "lower_bounds"], [3, 12, 1, "", "max_iterations"], [3, 10, 1, "", "optimize"], [3, 10, 1, "", "requires_gradients"], [3, 10, 1, "", "to_json"], [3, 12, 1, "", "upper_bounds"]], "cudaq.spin": [[3, 13, 1, "", "i"], [3, 13, 1, "", "x"], [3, 13, 1, "", "y"], [3, 13, 1, "", "z"]]}, "objtypes": {"0": "cpp:type", "1": "cpp:class", "2": "cpp:templateParam", "3": "cpp:function", "4": "cpp:functionParam", "5": "cpp:member", "6": "cpp:enum", "7": "cpp:enumerator", "8": "py:module", "9": "py:class", "10": "py:method", "11": "py:attribute", "12": "py:property", "13": "py:function"}, "objnames": {"0": ["cpp", "type", "C++ type"], "1": ["cpp", "class", "C++ class"], "2": ["cpp", "templateParam", "C++ template parameter"], "3": ["cpp", "function", "C++ function"], "4": ["cpp", "functionParam", "C++ function parameter"], "5": ["cpp", "member", "C++ member"], "6": ["cpp", "enum", "C++ enum"], "7": ["cpp", "enumerator", "C++ enumerator"], "8": ["py", "module", "Python module"], "9": ["py", "class", "Python class"], "10": ["py", "method", "Python method"], "11": ["py", "attribute", "Python attribute"], "12": ["py", "property", "Python property"], "13": ["py", "function", "Python function"]}, "titleterms": {"code": [0, 61], "document": 0, "cuda": [0, 2, 3, 13, 15, 16, 17, 18, 33, 34, 37, 38, 39, 40, 41, 45, 55, 56, 57, 58, 59, 61, 62, 63, 65, 66, 67], "q": [0, 2, 3, 13, 15, 16, 17, 18, 33, 34, 37, 38, 39, 40, 41, 45, 55, 56, 57, 58, 59, 61, 62, 63, 65, 66, 67], "api": [0, 2, 3], "quantum": [1, 2, 5, 7, 11, 13, 18, 21, 22, 25, 26, 27, 28, 30, 35, 47, 52, 53, 54], "oper": [1, 2, 25, 26], "unitari": 1, "qubit": [1, 6, 12, 25, 30], "x": 1, "y": 1, "z": 1, "h": 1, "r1": 1, "rx": 1, "ry": 1, "rz": 1, "": [1, 5, 21, 58], "t": 1, "swap": 1, "u3": 1, "adjoint": 1, "control": [1, 19, 49], "measur": [1, 53], "mz": 1, "mx": 1, "my": 1, "c": [2, 6, 34, 59], "common": [2, 27], "nois": [2, 12], "model": [2, 12, 23], "kernel": [2, 3, 20, 22, 36, 40], "builder": 2, "algorithm": [2, 5, 6, 18, 21, 52], "platform": [2, 28, 36], "util": 2, "namespac": [2, 24], "python": [3, 34, 59, 61], "program": [3, 21, 27, 39, 41], "construct": 3, "execut": [3, 35], "backend": [3, 33, 34, 35, 37], "configur": 3, "data": 3, "type": [3, 30], "optim": [3, 13, 18, 52], "gradient": [3, 18], "noisi": [3, 9, 51], "simul": [3, 9, 14, 35, 37, 42, 44, 51, 58, 61], "mpi": [3, 59, 61], "submodul": 3, "cost": 4, "minim": 4, "deutsch": 5, "xor": 5, "oplu": 5, "oracl": 5, "phase": [5, 21], "parallel": [5, 36, 46, 50], "hadamard": 6, "test": 6, "A": [6, 14], "numer": 6, "result": 6, "refer": [6, 14], "b": [6, 14], "us": [6, 13, 30, 47, 61, 63], "sampl": [6, 18, 21, 41], "primit": [6, 18], "ancilla": 6, "comput": [6, 27, 34, 46, 47, 53, 61], "expect": [6, 46], "valu": [6, 46], "multi": [6, 36, 37, 49, 50], "gpu": [6, 14, 35, 37, 41, 50, 61], "matrix": [6, 12, 37], "element": 6, "diagon": 6, "exampl": [6, 21, 45], "numpi": 6, "cupi": 6, "In": [6, 61], "thi": [6, 58], "sinc": 6, "we": 6, "ar": 6, "have": 6, "2x2": 6, "hybrid": 7, "neural": 7, "network": [7, 37], "molecular": 8, "dock": 8, "via": [8, 61], "dc": 8, "qaoa": [8, 10], "max": 10, "cut": 10, "fourier": 11, "transform": 11, "revisit": 11, "readout": 12, "error": 12, "mitig": 12, "invers": 12, "confus": 12, "from": [12, 34, 59], "singl": [12, 37], "k": 12, "local": [12, 61], "matric": 12, "full": 12, "variat": [13, 54], "eigensolv": [13, 54], "integr": [13, 64], "third": 13, "parti": 13, "water": 14, "molecul": 14, "activ": 14, "space": 14, "cpu": [14, 37], "v": [14, 61], "classic": 14, "ccsd": 14, "vqe": 14, "uccsd": 14, "content": [15, 38, 60], "releas": 16, "languag": 17, "specif": [17, 31], "cudaq": [18, 25, 26, 30], "observ": [18, 41], "deprec": [18, 30], "function": 18, "move": 18, "librari": [18, 59], "flow": 19, "just": 20, "time": 20, "creation": 20, "hello": 21, "world": 21, "simpl": 21, "bell": 21, "state": [21, 37, 53], "ghz": 21, "prepar": 21, "estim": 21, "deuteron": 21, "bind": 21, "energi": 21, "paramet": 21, "sweep": 21, "grover": 21, "iter": 21, "machin": 23, "standard": 24, "intrins": 25, "spin_op": 26, "pattern": 27, "action": [27, 58], "uncomput": 27, "sub": 29, "circuit": [29, 50, 58], "synthesi": [29, 49], "qudit": 30, "level": 30, "contain": [30, 61], "qview": 30, "2": 30, "qvector": 30, "qarrai": 30, "n": 30, "qspan": 30, "instead": 30, "qreg": 30, "quak": 32, "dialect": 32, "gener": 32, "introduct": [32, 48, 61], "motiv": 32, "target": [33, 50], "hardwar": [34, 47], "ionq": [34, 47], "set": 34, "credenti": 34, "submiss": 34, "iqm": [34, 47], "oqc": [34, 47], "orca": [34, 47], "quantinuum": [34, 47], "nvidia": [35, 36], "cloud": [35, 61], "quick": [35, 65], "start": [35, 61, 65], "select": 35, "multipl": [35, 46, 50], "qpu": 35, "asynchron": 35, "faq": 35, "processor": [36, 46, 50], "mqpu": 36, "distribut": [36, 61], "mode": [36, 37], "remot": [36, 61], "support": [36, 37, 59, 61], "argument": 36, "serial": 36, "vector": 37, "featur": 37, "environ": 37, "variabl": 37, "option": 37, "node": 37, "addit": [37, 61], "openmp": 37, "onli": 37, "tensor": 37, "product": 37, "default": 37, "basic": 38, "build": [39, 59], "your": [39, 41, 57, 65], "first": [39, 41], "what": 40, "i": 40, "run": 41, "troubleshoot": 42, "debug": 42, "verbos": 42, "output": 42, "bernstein": 43, "vazirani": 43, "cuquantum": 44, "across": [46, 50], "provid": 47, "workflow": 50, "avail": 50, "batch": 50, "hamiltonian": 50, "term": 50, "approxim": 52, "101": 53, "gate": 53, "visual": 53, "work": 55, "ir": 55, "extend": [56, 58], "creat": 57, "own": 57, "compil": 57, "pass": 57, "new": 58, "circuitsimul": 58, "requir": [58, 61], "subtyp": 58, "method": 58, "overrid": 58, "let": 58, "see": 58, "instal": [59, 60, 61, 65], "sourc": 59, "prerequisit": 59, "depend": [59, 61], "toolchain": 59, "host": [59, 61], "runtim": 59, "guid": 60, "docker": 61, "singular": 61, "wheel": 61, "pre": 61, "built": 61, "binari": 61, "develop": 61, "connect": 61, "tunnel": 61, "access": 61, "ssh": 61, "dgx": 61, "get": 61, "jupyterlab": 61, "tool": [61, 64], "pypi": 61, "imag": 61, "updat": 61, "compat": 61, "system": 61, "next": 61, "step": 61, "cmake": 62, "project": 63, "other": 64, "softwar": 64, "valid": 65, "tutori": 66, "version": 67}, "envversion": {"sphinx.domains.c": 2, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 8, "sphinx.domains.index": 1, "sphinx.domains.javascript": 2, "sphinx.domains.math": 2, "sphinx.domains.python": 3, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.intersphinx": 1, "nbsphinx": 4, "sphinx": 57}, "alltitles": {"Sub-circuit Synthesis": [[29, "sub-circuit-synthesis"]], "Common Quantum Programming Patterns": [[27, "common-quantum-programming-patterns"]], "Compute-Action-Uncompute": [[27, "compute-action-uncompute"]], "Quantum Platform": [[28, "quantum-platform"]], "Specifications": [[31, "specifications"]], "Quantum Intrinsic Operations": [[25, "quantum-intrinsic-operations"]], "Operations on cudaq::qubit": [[25, "operations-on-cudaq-qubit"]], "Quantum Operators": [[26, "quantum-operators"]], "cudaq::spin_op": [[26, "cudaq-spin-op"]], "Quantum Types": [[30, "quantum-types"]], "cudaq::qudit": [[30, "cudaq-qudit-levels"]], "cudaq::qubit": [[30, "cudaq-qubit"]], "Quantum Containers": [[30, "quantum-containers"]], "cudaq::qview": [[30, "cudaq-qview-levels-2"]], "cudaq::qvector": [[30, "cudaq-qvector-levels-2"]], "cudaq::qarray": [[30, "cudaq-qarray-n-levels-2"]], "cudaq::qspan (Deprecated. Use cudaq::qview instead.)": [[30, "cudaq-qspan-n-levels-deprecated-use-cudaq-qview-levels-instead"]], "cudaq::qreg (Deprecated. Use cudaq::qvector instead.)": [[30, "cudaq-qreg-n-levels-deprecated-use-cudaq-qvector-levels-instead"]], "Namespace and Standard": [[24, "namespace-and-standard"]], "Language Specification": [[17, "language-specification"]], "CUDA-Q": [[17, null], [15, "cuda-q"]], "Control Flow": [[19, "control-flow"]], "Quantum Kernels": [[22, "quantum-kernels"]], "Machine Model": [[23, "machine-model"]], "Just-in-Time Kernel Creation": [[20, "just-in-time-kernel-creation"]], "Example Programs": [[21, "example-programs"]], "Hello World - Simple Bell State": [[21, "hello-world-simple-bell-state"]], "GHZ State Preparation and Sampling": [[21, "ghz-state-preparation-and-sampling"]], "Quantum Phase Estimation": [[21, "quantum-phase-estimation"]], "Deuteron Binding Energy Parameter Sweep": [[21, "deuteron-binding-energy-parameter-sweep"]], "Grover\u2019s Algorithm": [[21, "grover-s-algorithm"]], "Iterative Phase Estimation": [[21, "iterative-phase-estimation"]], "CUDA-Q Releases": [[16, "cuda-q-releases"]], "Quantum Algorithmic Primitives": [[18, "quantum-algorithmic-primitives"]], "cudaq::sample": [[18, "cudaq-sample"]], "cudaq::observe": [[18, "cudaq-observe"]], "cudaq::optimizer (deprecated, functionality moved to CUDA-Q libraries)": [[18, "cudaq-optimizer-deprecated-functionality-moved-to-cuda-q-libraries"]], "cudaq::gradient (deprecated, functionality moved to CUDA-Q libraries)": [[18, "cudaq-gradient-deprecated-functionality-moved-to-cuda-q-libraries"]], "Using Quantum Hardware Providers": [[47, "using-quantum-hardware-providers"]], "IonQ": [[47, "ionq"], [34, "ionq"]], "IQM": [[47, "iqm"], [34, "iqm"]], "OQC": [[47, "oqc"], [34, "oqc"]], "ORCA Computing": [[47, "orca-computing"], [34, "orca-computing"]], "Quantinuum": [[47, "quantinuum"], [34, "quantinuum"]], "Simulations with cuQuantum": [[44, "simulations-with-cuquantum"]], "Troubleshooting": [[42, "troubleshooting"]], "Debugging and Verbose Simulation Output": [[42, "debugging-and-verbose-simulation-output"]], "What is a CUDA-Q kernel?": [[40, "what-is-a-cuda-q-kernel"]], "CUDA-Q by Example": [[45, "cuda-q-by-example"]], "Computing Expectation Values": [[46, "computing-expectation-values"]], "Parallelizing across Multiple Processors": [[46, "parallelizing-across-multiple-processors"]], "Bernstein-Vazirani": [[43, "bernstein-vazirani"]], "Running your first CUDA-Q Program": [[41, "running-your-first-cuda-q-program"]], "Sample": [[41, "sample"]], "Observe": [[41, "observe"]], "Running on a GPU": [[41, "running-on-a-gpu"]], "CUDA-Q Basics": [[38, "cuda-q-basics"]], "Contents": [[38, null], [60, null], [15, null]], "Building your first CUDA-Q Program": [[39, "building-your-first-cuda-q-program"]], "NVIDIA Quantum Cloud": [[35, "nvidia-quantum-cloud"]], "Quick Start": [[35, "quick-start"], [65, "quick-start"]], "Simulator Backend Selection": [[35, "simulator-backend-selection"]], "Multiple GPUs": [[35, "multiple-gpus"]], "Simulator Backends": [[35, "id1"]], "Multiple QPUs Asynchronous Execution": [[35, "multiple-qpus-asynchronous-execution"]], "FAQ": [[35, "faq"]], "CUDA-Q Simulation Backends": [[37, "cuda-q-simulation-backends"]], "State Vector Simulators": [[37, "state-vector-simulators"]], "Features": [[37, "features"]], "Single-GPU": [[37, "single-gpu"]], "Environment variable options supported in single-GPU mode": [[37, "id4"]], "Multi-node multi-GPU": [[37, "multi-node-multi-gpu"], [37, "id2"]], "Additional environment variable options for multi-node multi-GPU mode": [[37, "id5"]], "OpenMP CPU-only": [[37, "openmp-cpu-only"]], "Tensor Network Simulators": [[37, "tensor-network-simulators"]], "Matrix product state": [[37, "matrix-product-state"]], "Default Simulator": [[37, "default-simulator"]], "Quake Dialect": [[32, "quake-dialect"]], "General Introduction": [[32, "general-introduction"]], "Motivation": [[32, "motivation"]], "CUDA-Q Hardware Backends": [[34, "cuda-q-hardware-backends"]], "Setting Credentials": [[34, "setting-credentials"], [34, "id1"], [34, "id4"], [34, "id7"], [34, "quantinuum-backend"]], "Submission from C++": [[34, "submission-from-c"], [34, "id2"], [34, "id5"], [34, "id8"], [34, "id11"]], "Submission from Python": [[34, "submission-from-python"], [34, "id3"], [34, "id6"], [34, "id9"], [34, "id12"]], "Multi-Processor Platforms": [[36, "multi-processor-platforms"]], "NVIDIA MQPU Platform": [[36, "nvidia-mqpu-platform"]], "Parallel distribution mode": [[36, "parallel-distribution-mode"]], "Remote MQPU Platform": [[36, "remote-mqpu-platform"]], "Supported Kernel Arguments": [[36, "supported-kernel-arguments"]], "Kernel argument serialization": [[36, "id2"]], "CUDA-Q Backends": [[33, "cuda-q-backends"]], "Backend Targets": [[33, null]], "Introduction": [[48, "introduction"], [61, "introduction"]], "Variational Quantum Eigensolver": [[54, "variational-quantum-eigensolver"], [13, "Variational-Quantum-Eigensolver"]], "Quantum Approximate Optimization Algorithm": [[52, "quantum-approximate-optimization-algorithm"]], "Multi-control Synthesis": [[49, "multi-control-synthesis"]], "Multi-GPU Workflows": [[50, "multi-gpu-workflows"]], "Available Targets": [[50, "available-targets"]], "Parallelization across Multiple Processors": [[50, "parallelization-across-multiple-processors"]], "Batching Hamiltonian Terms": [[50, "batching-hamiltonian-terms"]], "Circuit Batching": [[50, "circuit-batching"]], "Working with the CUDA-Q IR": [[55, "working-with-the-cuda-q-ir"]], "Noisy Simulation": [[51, "noisy-simulation"], [9, "Noisy-Simulation"], [3, "noisy-simulation"]], "Quantum Computing 101": [[53, "quantum-computing-101"]], "Quantum States": [[53, "quantum-states"]], "Quantum Gates": [[53, "quantum-gates"]], "Measurements": [[53, "measurements"]], "State Visualization": [[53, "state-visualization"]], "Create your own CUDA-Q Compiler Pass": [[57, "create-your-own-cuda-q-compiler-pass"]], "Local Installation": [[61, "local-installation"]], "Docker": [[61, "docker"]], "Singularity": [[61, "singularity"]], "Python wheels": [[61, "python-wheels"]], "Pre-built binaries": [[61, "pre-built-binaries"]], "Development with VS Code": [[61, "development-with-vs-code"]], "Using a Docker container": [[61, "using-a-docker-container"]], "Using a Singularity container": [[61, "using-a-singularity-container"]], "Connecting to a Remote Host": [[61, "connecting-to-a-remote-host"]], "Developing with Remote Tunnels": [[61, "developing-with-remote-tunnels"]], "Remote Access via SSH": [[61, "remote-access-via-ssh"]], "DGX Cloud": [[61, "dgx-cloud"]], "Get Started": [[61, "get-started"]], "Use JupyterLab": [[61, "use-jupyterlab"]], "Use VS Code": [[61, "use-vs-code"]], "Additional CUDA Tools": [[61, "additional-cuda-tools"]], "Installation via PyPI": [[61, "installation-via-pypi"]], "Installation In Container Images": [[61, "installation-in-container-images"]], "Installing Pre-built Binaries": [[61, "installing-pre-built-binaries"]], "Distributed Computing with MPI": [[61, "distributed-computing-with-mpi"]], "Updating CUDA-Q": [[61, "updating-cuda-q"]], "Dependencies and Compatibility": [[61, "dependencies-and-compatibility"]], "Supported Systems": [[61, "id10"]], "Requirements for GPU Simulation": [[61, "id11"]], "Next Steps": [[61, "next-steps"]], "Installation from Source": [[59, "installation-from-source"]], "Prerequisites": [[59, "prerequisites"]], "Build Dependencies": [[59, "build-dependencies"]], "CUDA": [[59, "cuda"]], "Toolchain": [[59, "toolchain"]], "Building CUDA-Q": [[59, "building-cuda-q"]], "C++ Support": [[59, "c-support"]], "Python Support": [[59, "python-support"]], "Installation on the Host": [[59, "installation-on-the-host"]], "CUDA Runtime Libraries": [[59, "cuda-runtime-libraries"]], "MPI": [[59, "mpi"]], "CUDA-Q and CMake": [[62, "cuda-q-and-cmake"]], "Using CUDA and CUDA-Q in a Project": [[63, "using-cuda-and-cuda-q-in-a-project"]], "Extending CUDA-Q with a new Simulator": [[58, "extending-cuda-q-with-a-new-simulator"]], "CircuitSimulator": [[58, "circuitsimulator"]], "Required Circuit Simulator Subtype Method Overrides": [[58, "id1"]], "Let\u2019s see this in action": [[58, "let-s-see-this-in-action"]], "Installation Guide": [[60, "installation-guide"]], "Extending CUDA-Q": [[56, "extending-cuda-q"]], "Install CUDA-Q": [[65, "install-cuda-q"]], "Validate your Installation": [[65, "validate-your-installation"]], "CUDA-Q Versions": [[67, "cuda-q-versions"]], "Integration with other Software Tools": [[64, "integration-with-other-software-tools"]], "CUDA-Q Tutorials": [[66, "cuda-q-tutorials"]], "Water Molecule with Active Space (CPU vs. GPU)": [[14, "Water-Molecule-with-Active-Space-(CPU-vs.-GPU)"]], "A- Classical simulation as a reference: CCSD": [[14, "A--Classical-simulation-as-a-reference:-CCSD"]], "B- VQE-UCCSD:": [[14, "B--VQE-UCCSD:"]], "Molecular docking via DC-QAOA": [[8, "Molecular-docking-via-DC-QAOA"]], "Quantum Fourier Transform": [[11, "Quantum-Fourier-Transform"]], "Quantum Fourier Transform revisited": [[11, "Quantum-Fourier-Transform-revisited"]], "Max-Cut with QAOA": [[10, "Max-Cut-with-QAOA"]], "Readout Error Mitigation": [[12, "Readout-Error-Mitigation"]], "Inverse confusion matrix from single-qubit noise model": [[12, "Inverse-confusion-matrix-from-single-qubit-noise-model"]], "Inverse confusion matrix from k local confusion matrices": [[12, "Inverse-confusion-matrix-from-k-local-confusion-matrices"]], "Inverse of full confusion matrix": [[12, "Inverse-of-full-confusion-matrix"]], "Using CUDA-Q Optimizers": [[13, "Using-CUDA-Q-Optimizers"]], "Integration with Third-Party Optimizers": [[13, "Integration-with-Third-Party-Optimizers"]], "CUDA-Q C++ API": [[2, "cuda-q-c-api"]], "Operators": [[2, "operators"]], "Quantum": [[2, "quantum"]], "Common": [[2, "common"]], "Noise Modeling": [[2, "noise-modeling"]], "Kernel Builder": [[2, "kernel-builder"]], "Algorithms": [[2, "algorithms"]], "Platform": [[2, "platform"]], "Utilities": [[2, "utilities"]], "Namespaces": [[2, "namespaces"]], "Cost Minimization": [[4, "Cost-Minimization"]], "CUDA-Q Python API": [[3, "module-cudaq"]], "Program Construction": [[3, "program-construction"]], "Kernel Execution": [[3, "kernel-execution"]], "Backend Configuration": [[3, "backend-configuration"]], "Data Types": [[3, "data-types"]], "Optimizers": [[3, "optimizers"]], "Gradients": [[3, "gradients"]], "MPI Submodule": [[3, "mpi-submodule"]], "Quantum Operations": [[1, "quantum-operations"]], "Unitary Operations on Qubits": [[1, "unitary-operations-on-qubits"]], "x": [[1, "x"]], "y": [[1, "y"]], "z": [[1, "z"]], "h": [[1, "h"]], "r1": [[1, "r1"]], "rx": [[1, "rx"]], "ry": [[1, "ry"]], "rz": [[1, "rz"]], "s": [[1, "s"]], "t": [[1, "t"]], "swap": [[1, "swap"]], "u3": [[1, "u3"]], "Adjoint and Controlled Operations": [[1, "adjoint-and-controlled-operations"]], "Measurements on Qubits": [[1, "measurements-on-qubits"]], "mz": [[1, "mz"]], "mx": [[1, "mx"]], "my": [[1, "my"]], "Deutsch\u2019s Algorithm": [[5, "Deutsch's-Algorithm"]], "XOR \\oplus": [[5, "XOR-\\oplus"]], "Quantum oracles": [[5, "Quantum-oracles"]], "Phase oracle": [[5, "Phase-oracle"]], "Quantum parallelism": [[5, "Quantum-parallelism"]], "Deutschs\u2019 Algorithm:": [[5, "Deutschs'-Algorithm:"]], "Hadamard Test": [[6, "Hadamard-Test"]], "A- Numerical result as a reference:": [[6, "A--Numerical-result-as-a-reference:"]], "B- Using sample algorithmic primitive to sample the ancilla qubit and compute the expectation value.": [[6, "B--Using-sample-algorithmic-primitive-to-sample-the-ancilla-qubit-and-compute-the-expectation-value."]], "C- Use multi-GPUs to compute the matrix elements": [[6, "C--Use-multi-GPUs-to-compute-the-matrix-elements"]], "Diagonalize the matrix using for example Numpy or CuPy. In this example, since we are having 2x2 matrix, we use numpy.": [[6, "Diagonalize-the-matrix-using-for-example-Numpy-or-CuPy.-In-this-example,-since-we-are-having-2x2-matrix,-we-use-numpy."]], "Hybrid Quantum Neural Networks": [[7, "Hybrid-Quantum-Neural-Networks"]], "Code documentation": [[0, "code-documentation"]], "CUDA-Q API": [[0, null]]}, "indexentries": {"cudaq (c++ type)": [[2, "_CPPv45cudaq"]], "cudaq::basenvcfsimulatorqpu (c++ class)": [[2, "_CPPv4N5cudaq20BaseNvcfSimulatorQPUE"]], "cudaq::baseremoterestqpu (c++ class)": [[2, "_CPPv4N5cudaq17BaseRemoteRESTQPUE"]], "cudaq::baseremotesimulatorqpu (c++ class)": [[2, "_CPPv4N5cudaq22BaseRemoteSimulatorQPUE"]], "cudaq::cusvstate (c++ class)": [[2, "_CPPv4I0EN5cudaq9CusvStateE"]], "cudaq::executioncontext (c++ class)": [[2, "_CPPv4N5cudaq16ExecutionContextE"]], "cudaq::executioncontext::executioncontext (c++ function)": [[2, "_CPPv4N5cudaq16ExecutionContext16ExecutionContextEKNSt6stringE"], [2, "_CPPv4N5cudaq16ExecutionContext16ExecutionContextEKNSt6stringENSt6size_tE"]], "cudaq::executioncontext::amplitudemaps (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext13amplitudeMapsE"]], "cudaq::executioncontext::asyncexec (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext9asyncExecE"]], "cudaq::executioncontext::batchiteration (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext14batchIterationE"]], "cudaq::executioncontext::canhandleobserve (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext16canHandleObserveE"]], "cudaq::executioncontext::expectationvalue (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext16expectationValueE"]], "cudaq::executioncontext::futureresult (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext12futureResultE"]], "cudaq::executioncontext::hasconditionalsonmeasureresults (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext31hasConditionalsOnMeasureResultsE"]], "cudaq::executioncontext::invocationresultbuffer (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext22invocationResultBufferE"]], "cudaq::executioncontext::kernelname (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext10kernelNameE"]], "cudaq::executioncontext::kerneltrace (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext11kernelTraceE"]], "cudaq::executioncontext::name (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext4nameE"]], "cudaq::executioncontext::noisemodel (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext10noiseModelE"]], "cudaq::executioncontext::optresult (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext9optResultE"]], "cudaq::executioncontext::overlapcomputestates (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext20overlapComputeStatesE"]], "cudaq::executioncontext::overlapresult (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext13overlapResultE"]], "cudaq::executioncontext::registernames (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext13registerNamesE"]], "cudaq::executioncontext::reorderidx (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext10reorderIdxE"]], "cudaq::executioncontext::result (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext6resultE"]], "cudaq::executioncontext::shots (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext5shotsE"]], "cudaq::executioncontext::simulationstate (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext15simulationStateE"]], "cudaq::executioncontext::spin (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext4spinE"]], "cudaq::executioncontext::totaliterations (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext15totalIterationsE"]], "cudaq::executionresult (c++ struct)": [[2, "_CPPv4N5cudaq15ExecutionResultE"]], "cudaq::executionresult::executionresult (c++ function)": [[2, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionary"], [2, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryNSt6stringE"], [2, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryd"], [2, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultENSt6stringE"], [2, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultERK15ExecutionResult"], [2, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultEd"], [2, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultEv"]], "cudaq::executionresult::appendresult (c++ function)": [[2, "_CPPv4N5cudaq15ExecutionResult12appendResultENSt6stringENSt6size_tE"]], "cudaq::executionresult::deserialize (c++ function)": [[2, "_CPPv4N5cudaq15ExecutionResult11deserializeERNSt6vectorINSt6size_tEEE"]], "cudaq::executionresult::operator= (c++ function)": [[2, "_CPPv4N5cudaq15ExecutionResultaSERK15ExecutionResult"]], "cudaq::executionresult::operator== (c++ function)": [[2, "_CPPv4NK5cudaq15ExecutionResulteqERK15ExecutionResult"]], "cudaq::executionresult::registername (c++ member)": [[2, "_CPPv4N5cudaq15ExecutionResult12registerNameE"]], "cudaq::executionresult::sequentialdata (c++ member)": [[2, "_CPPv4N5cudaq15ExecutionResult14sequentialDataE"]], "cudaq::executionresult::serialize (c++ function)": [[2, "_CPPv4NK5cudaq15ExecutionResult9serializeEv"]], "cudaq::kernelexecutiontask (c++ type)": [[2, "_CPPv4N5cudaq19KernelExecutionTaskE"]], "cudaq::qpu (c++ class)": [[2, "_CPPv4N5cudaq3QPUE"]], "cudaq::qpu::qpu (c++ function)": [[2, "_CPPv4N5cudaq3QPU3QPUENSt6size_tE"], [2, "_CPPv4N5cudaq3QPU3QPUERR3QPU"], [2, "_CPPv4N5cudaq3QPU3QPUEv"]], "cudaq::qpu::enqueue (c++ function)": [[2, "_CPPv4N5cudaq3QPU7enqueueER11QuantumTask"]], "cudaq::qpu::getconnectivity (c++ function)": [[2, "_CPPv4N5cudaq3QPU15getConnectivityEv"]], "cudaq::qpu::getexecutionthreadid (c++ function)": [[2, "_CPPv4NK5cudaq3QPU20getExecutionThreadIdEv"]], "cudaq::qpu::getnumqubits (c++ function)": [[2, "_CPPv4N5cudaq3QPU12getNumQubitsEv"]], "cudaq::qpu::getremotecapabilities (c++ function)": [[2, "_CPPv4NK5cudaq3QPU21getRemoteCapabilitiesEv"]], "cudaq::qpu::isemulated (c++ function)": [[2, "_CPPv4N5cudaq3QPU10isEmulatedEv"]], "cudaq::qpu::issimulator (c++ function)": [[2, "_CPPv4N5cudaq3QPU11isSimulatorEv"]], "cudaq::qpu::launchkernel (c++ function)": [[2, "_CPPv4N5cudaq3QPU12launchKernelERKNSt6stringEPFvPvEPvNSt8uint64_tENSt8uint64_tE"]], "cudaq::qpu::launchserializedcodeexecution (c++ function)": [[2, "_CPPv4N5cudaq3QPU29launchSerializedCodeExecutionERKNSt6stringERN5cudaq30SerializedCodeExecutionContextE"]], "cudaq::qpu::onrandomseedset (c++ function)": [[2, "_CPPv4N5cudaq3QPU15onRandomSeedSetENSt6size_tE"]], "cudaq::qpu::resetexecutioncontext (c++ function)": [[2, "_CPPv4N5cudaq3QPU21resetExecutionContextEv"]], "cudaq::qpu::setexecutioncontext (c++ function)": [[2, "_CPPv4N5cudaq3QPU19setExecutionContextEP16ExecutionContext"]], "cudaq::qpu::setid (c++ function)": [[2, "_CPPv4N5cudaq3QPU5setIdENSt6size_tE"]], "cudaq::qpu::setshots (c++ function)": [[2, "_CPPv4N5cudaq3QPU8setShotsEi"]], "cudaq::qpu::supportsconditionalfeedback (c++ function)": [[2, "_CPPv4N5cudaq3QPU27supportsConditionalFeedbackEv"]], "cudaq::qpu::~qpu (c++ function)": [[2, "_CPPv4N5cudaq3QPUD0Ev"]], "cudaq::quakevalue (c++ class)": [[2, "_CPPv4N5cudaq10QuakeValueE"]], "cudaq::quakevalue::quakevalue (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEN4mlir5ValueE"], [2, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEd"]], "cudaq::quakevalue::canvalidatenumelements (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue22canValidateNumElementsEv"]], "cudaq::quakevalue::constantsize (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue12constantSizeEv"]], "cudaq::quakevalue::dump (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue4dumpERNSt7ostreamE"], [2, "_CPPv4N5cudaq10QuakeValue4dumpEv"]], "cudaq::quakevalue::getrequiredelements (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue19getRequiredElementsEv"]], "cudaq::quakevalue::getvalue (c++ function)": [[2, "_CPPv4NK5cudaq10QuakeValue8getValueEv"]], "cudaq::quakevalue::inverse (c++ function)": [[2, "_CPPv4NK5cudaq10QuakeValue7inverseEv"]], "cudaq::quakevalue::isstdvec (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue8isStdVecEv"]], "cudaq::quakevalue::operator* (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValuemlE10QuakeValue"], [2, "_CPPv4N5cudaq10QuakeValuemlEKd"]], "cudaq::quakevalue::operator+ (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValueplE10QuakeValue"], [2, "_CPPv4N5cudaq10QuakeValueplEKd"], [2, "_CPPv4N5cudaq10QuakeValueplEKi"]], "cudaq::quakevalue::operator- (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValuemiE10QuakeValue"], [2, "_CPPv4N5cudaq10QuakeValuemiEKd"], [2, "_CPPv4N5cudaq10QuakeValuemiEKi"], [2, "_CPPv4NK5cudaq10QuakeValuemiEv"]], "cudaq::quakevalue::operator/ (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValuedvE10QuakeValue"], [2, "_CPPv4N5cudaq10QuakeValuedvEKd"]], "cudaq::quakevalue::operator[] (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValueixEKNSt6size_tE"], [2, "_CPPv4N5cudaq10QuakeValueixERK10QuakeValue"]], "cudaq::quakevalue::size (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue4sizeEv"]], "cudaq::quakevalue::slice (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue5sliceEKNSt6size_tEKNSt6size_tE"]], "cudaq::quantumtask (c++ type)": [[2, "_CPPv4N5cudaq11QuantumTaskE"]], "cudaq::qubitconnectivity (c++ type)": [[2, "_CPPv4N5cudaq17QubitConnectivityE"]], "cudaq::qubitedge (c++ type)": [[2, "_CPPv4N5cudaq9QubitEdgeE"]], "cudaq::remotecapabilities (c++ struct)": [[2, "_CPPv4N5cudaq18RemoteCapabilitiesE"]], "cudaq::remotecapabilities::remotecapabilities (c++ function)": [[2, "_CPPv4N5cudaq18RemoteCapabilities18RemoteCapabilitiesEb"]], "cudaq::remotecapabilities::serializedcodeexec (c++ member)": [[2, "_CPPv4N5cudaq18RemoteCapabilities18serializedCodeExecE"]], "cudaq::remotecapabilities::stateoverlap (c++ member)": [[2, "_CPPv4N5cudaq18RemoteCapabilities12stateOverlapE"]], "cudaq::remotecapabilities::vqe (c++ member)": [[2, "_CPPv4N5cudaq18RemoteCapabilities3vqeE"]], "cudaq::remotesimulationstate (c++ class)": [[2, "_CPPv4N5cudaq21RemoteSimulationStateE"]], "cudaq::resources (c++ class)": [[2, "_CPPv4N5cudaq9ResourcesE"]], "cudaq::serializedcodeexecutioncontext (c++ class)": [[2, "_CPPv4N5cudaq30SerializedCodeExecutionContextE"]], "cudaq::simulationstate (c++ class)": [[2, "_CPPv4N5cudaq15SimulationStateE"]], "cudaq::simulationstate::tensor (c++ struct)": [[2, "_CPPv4N5cudaq15SimulationState6TensorE"]], "cudaq::simulationstate::precision (c++ enum)": [[2, "_CPPv4N5cudaq15SimulationState9precisionE"]], "cudaq::simulationstate::precision::fp32 (c++ enumerator)": [[2, "_CPPv4N5cudaq15SimulationState9precision4fp32E"]], "cudaq::simulationstate::precision::fp64 (c++ enumerator)": [[2, "_CPPv4N5cudaq15SimulationState9precision4fp64E"]], "cudaq::tensorstatedata (c++ type)": [[2, "_CPPv4N5cudaq15TensorStateDataE"]], "cudaq::trace (c++ class)": [[2, "_CPPv4N5cudaq5TraceE"]], "cudaq::amplitude_damping_channel (c++ class)": [[2, "_CPPv4N5cudaq25amplitude_damping_channelE"]], "cudaq::async_result (c++ class)": [[2, "_CPPv4I0EN5cudaq12async_resultE"]], "cudaq::async_result::get (c++ function)": [[2, "_CPPv4N5cudaq12async_result3getEv"]], "cudaq::bit_flip_channel (c++ class)": [[2, "_CPPv4N5cudaq16bit_flip_channelE"]], "cudaq::complex (c++ type)": [[2, "_CPPv4N5cudaq7complexE"]], "cudaq::complex_matrix (c++ class)": [[2, "_CPPv4N5cudaq14complex_matrixE"]], "cudaq::complex_matrix::cols (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrix4colsEv"]], "cudaq::complex_matrix::complex_matrix (c++ function)": [[2, "_CPPv4N5cudaq14complex_matrix14complex_matrixEKNSt6size_tEKNSt6size_tE"], [2, "_CPPv4N5cudaq14complex_matrix14complex_matrixEP10value_typeKNSt6size_tEKNSt6size_tE"]], "cudaq::complex_matrix::data (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrix4dataEv"]], "cudaq::complex_matrix::dump (c++ function)": [[2, "_CPPv4N5cudaq14complex_matrix4dumpERNSt7ostreamE"], [2, "_CPPv4N5cudaq14complex_matrix4dumpEv"]], "cudaq::complex_matrix::eigenvalues (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrix11eigenvaluesEv"]], "cudaq::complex_matrix::eigenvectors (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrix12eigenvectorsEv"]], "cudaq::complex_matrix::minimal_eigenvalue (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrix18minimal_eigenvalueEv"]], "cudaq::complex_matrix::operator() (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrixclENSt6size_tENSt6size_tE"]], "cudaq::complex_matrix::operator* (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrixmlER14complex_matrix"], [2, "_CPPv4NK5cudaq14complex_matrixmlERNSt6vectorI10value_typeEE"]], "cudaq::complex_matrix::rows (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrix4rowsEv"]], "cudaq::complex_matrix::set_zero (c++ function)": [[2, "_CPPv4N5cudaq14complex_matrix8set_zeroEv"]], "cudaq::complex_matrix::value_type (c++ type)": [[2, "_CPPv4N5cudaq14complex_matrix10value_typeE"]], "cudaq::depolarization_channel (c++ class)": [[2, "_CPPv4N5cudaq22depolarization_channelE"]], "cudaq::details (c++ type)": [[2, "_CPPv4N5cudaq7detailsE"]], "cudaq::details::kernelbuildertype (c++ class)": [[2, "_CPPv4N5cudaq7details17KernelBuilderTypeE"]], "cudaq::details::kernelbuildertype::kernelbuildertype (c++ function)": [[2, "_CPPv4N5cudaq7details17KernelBuilderType17KernelBuilderTypeERRNSt8functionIFN4mlir4TypeEPN4mlir11MLIRContextEEEE"]], "cudaq::details::kernelbuildertype::create (c++ function)": [[2, "_CPPv4N5cudaq7details17KernelBuilderType6createEPN4mlir11MLIRContextE"]], "cudaq::details::future (c++ class)": [[2, "_CPPv4N5cudaq7details6futureE"]], "cudaq::details::future::future (c++ function)": [[2, "_CPPv4N5cudaq7details6future6futureERNSt6vectorI3JobEERNSt6stringERNSt3mapINSt6stringENSt6stringEEE"], [2, "_CPPv4N5cudaq7details6future6futureERR6future"], [2, "_CPPv4N5cudaq7details6future6futureEv"]], "cudaq::details::kernel_builder_base (c++ class)": [[2, "_CPPv4N5cudaq7details19kernel_builder_baseE"]], "cudaq::details::kernel_builder_base::operator<< (c++ function)": [[2, "_CPPv4N5cudaq7details19kernel_builder_baselsERNSt7ostreamERK19kernel_builder_base"]], "cudaq::draw (c++ function)": [[2, "_CPPv4I0Dp0EN5cudaq4drawENSt6stringERR13QuantumKernelDpRR4Args"]], "cudaq::dyn (c++ member)": [[2, "_CPPv4N5cudaq3dynE"]], "cudaq::gradient (c++ class)": [[2, "_CPPv4N5cudaq8gradientE"]], "cudaq::gradient::clone (c++ function)": [[2, "_CPPv4N5cudaq8gradient5cloneEv"]], "cudaq::gradient::compute (c++ function)": [[2, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd"], [2, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd"]], "cudaq::gradient::gradient (c++ function)": [[2, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelT"], [2, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelTRR10ArgsMapper"], [2, "_CPPv4I00EN5cudaq8gradient8gradientERR13QuantumKernelRR10ArgsMapper"], [2, "_CPPv4N5cudaq8gradient8gradientERRNSt8functionIFvNSt6vectorIdEEEEE"], [2, "_CPPv4N5cudaq8gradient8gradientEv"]], "cudaq::gradient::setargs (c++ function)": [[2, "_CPPv4I0DpEN5cudaq8gradient7setArgsEvR13QuantumKernelDpRR4Args"]], "cudaq::gradient::setkernel (c++ function)": [[2, "_CPPv4I0EN5cudaq8gradient9setKernelEvR13QuantumKernel"]], "cudaq::gradients::central_difference (c++ class)": [[2, "_CPPv4N5cudaq9gradients18central_differenceE"]], "cudaq::gradients::central_difference::clone (c++ function)": [[2, "_CPPv4N5cudaq9gradients18central_difference5cloneEv"]], "cudaq::gradients::central_difference::compute (c++ function)": [[2, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd"], [2, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd"]], "cudaq::gradients::central_difference::gradient (c++ function)": [[2, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelT"], [2, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelTRR10ArgsMapper"], [2, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientERR13QuantumKernelRR10ArgsMapper"], [2, "_CPPv4N5cudaq9gradients18central_difference8gradientERRNSt8functionIFvNSt6vectorIdEEEEE"], [2, "_CPPv4N5cudaq9gradients18central_difference8gradientEv"]], "cudaq::gradients::forward_difference (c++ class)": [[2, "_CPPv4N5cudaq9gradients18forward_differenceE"]], "cudaq::gradients::forward_difference::clone (c++ function)": [[2, "_CPPv4N5cudaq9gradients18forward_difference5cloneEv"]], "cudaq::gradients::forward_difference::compute (c++ function)": [[2, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd"], [2, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd"]], "cudaq::gradients::forward_difference::gradient (c++ function)": [[2, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelT"], [2, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelTRR10ArgsMapper"], [2, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientERR13QuantumKernelRR10ArgsMapper"], [2, "_CPPv4N5cudaq9gradients18forward_difference8gradientERRNSt8functionIFvNSt6vectorIdEEEEE"], [2, "_CPPv4N5cudaq9gradients18forward_difference8gradientEv"]], "cudaq::gradients::parameter_shift (c++ class)": [[2, "_CPPv4N5cudaq9gradients15parameter_shiftE"]], "cudaq::gradients::parameter_shift::clone (c++ function)": [[2, "_CPPv4N5cudaq9gradients15parameter_shift5cloneEv"]], "cudaq::gradients::parameter_shift::compute (c++ function)": [[2, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd"], [2, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd"]], "cudaq::gradients::parameter_shift::gradient (c++ function)": [[2, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelT"], [2, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelTRR10ArgsMapper"], [2, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientERR13QuantumKernelRR10ArgsMapper"], [2, "_CPPv4N5cudaq9gradients15parameter_shift8gradientERRNSt8functionIFvNSt6vectorIdEEEEE"], [2, "_CPPv4N5cudaq9gradients15parameter_shift8gradientEv"]], "cudaq::kernel_builder (c++ class)": [[2, "_CPPv4IDpEN5cudaq14kernel_builderE"]], "cudaq::kernel_builder::constantval (c++ function)": [[2, "_CPPv4N5cudaq14kernel_builder11constantValEd"]], "cudaq::kernel_builder::getarguments (c++ function)": [[2, "_CPPv4N5cudaq14kernel_builder12getArgumentsEv"]], "cudaq::kernel_builder::getnumparams (c++ function)": [[2, "_CPPv4N5cudaq14kernel_builder12getNumParamsEv"]], "cudaq::kernel_builder::isargstdvec (c++ function)": [[2, "_CPPv4N5cudaq14kernel_builder11isArgStdVecENSt6size_tE"]], "cudaq::kernel_builder::kernel_builder (c++ function)": [[2, "_CPPv4N5cudaq14kernel_builder14kernel_builderERNSt6vectorIN7details17KernelBuilderTypeEEE"]], "cudaq::kernel_builder::name (c++ function)": [[2, "_CPPv4N5cudaq14kernel_builder4nameEv"]], "cudaq::kernel_builder::qalloc (c++ function)": [[2, "_CPPv4N5cudaq14kernel_builder6qallocE10QuakeValue"], [2, "_CPPv4N5cudaq14kernel_builder6qallocEKNSt6size_tE"], [2, "_CPPv4N5cudaq14kernel_builder6qallocERNSt6vectorINSt7complexIdEEEE"], [2, "_CPPv4N5cudaq14kernel_builder6qallocEv"]], "cudaq::kernel_builder::swap (c++ function)": [[2, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRK10QuakeValueRK10QuakeValueRK10QuakeValue"], [2, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRKNSt6vectorI10QuakeValueEERK10QuakeValueRK10QuakeValue"], [2, "_CPPv4N5cudaq14kernel_builder4swapERK10QuakeValueRK10QuakeValue"]], "cudaq::kraus_channel (c++ class)": [[2, "_CPPv4N5cudaq13kraus_channelE"]], "cudaq::kraus_channel::empty (c++ function)": [[2, "_CPPv4NK5cudaq13kraus_channel5emptyEv"]], "cudaq::kraus_channel::get_ops (c++ function)": [[2, "_CPPv4N5cudaq13kraus_channel7get_opsEv"]], "cudaq::kraus_channel::kraus_channel (c++ function)": [[2, "_CPPv4IDpEN5cudaq13kraus_channel13kraus_channelEDpRRNSt16initializer_listI1TEE"], [2, "_CPPv4N5cudaq13kraus_channel13kraus_channelERK13kraus_channel"], [2, "_CPPv4N5cudaq13kraus_channel13kraus_channelERNSt6vectorI8kraus_opEE"], [2, "_CPPv4N5cudaq13kraus_channel13kraus_channelERRNSt6vectorI8kraus_opEE"], [2, "_CPPv4N5cudaq13kraus_channel13kraus_channelEv"]], "cudaq::kraus_channel::operator= (c++ function)": [[2, "_CPPv4N5cudaq13kraus_channelaSERK13kraus_channel"]], "cudaq::kraus_channel::operator[] (c++ function)": [[2, "_CPPv4N5cudaq13kraus_channelixEKNSt6size_tE"]], "cudaq::kraus_channel::push_back (c++ function)": [[2, "_CPPv4N5cudaq13kraus_channel9push_backE8kraus_op"]], "cudaq::kraus_channel::size (c++ function)": [[2, "_CPPv4NK5cudaq13kraus_channel4sizeEv"]], "cudaq::kraus_op (c++ struct)": [[2, "_CPPv4N5cudaq8kraus_opE"]], "cudaq::kraus_op::adjoint (c++ function)": [[2, "_CPPv4NK5cudaq8kraus_op7adjointEv"]], "cudaq::kraus_op::data (c++ member)": [[2, "_CPPv4N5cudaq8kraus_op4dataE"]], "cudaq::kraus_op::kraus_op (c++ function)": [[2, "_CPPv4I0EN5cudaq8kraus_op8kraus_opERRNSt16initializer_listI1TEE"], [2, "_CPPv4N5cudaq8kraus_op8kraus_opENSt6vectorIN5cudaq7complexEEE"], [2, "_CPPv4N5cudaq8kraus_op8kraus_opERK8kraus_op"]], "cudaq::kraus_op::ncols (c++ member)": [[2, "_CPPv4N5cudaq8kraus_op5nColsE"]], "cudaq::kraus_op::nrows (c++ member)": [[2, "_CPPv4N5cudaq8kraus_op5nRowsE"]], "cudaq::kraus_op::operator= (c++ function)": [[2, "_CPPv4N5cudaq8kraus_opaSERK8kraus_op"]], "cudaq::mpi (c++ type)": [[2, "_CPPv4N5cudaq3mpiE"]], "cudaq::mpi::all_gather (c++ function)": [[2, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIdEERKNSt6vectorIdEE"], [2, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIiEERKNSt6vectorIiEE"]], "cudaq::mpi::all_reduce (c++ function)": [[2, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK14BinaryFunction"], [2, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK4Func"]], "cudaq::mpi::broadcast (c++ function)": [[2, "_CPPv4N5cudaq3mpi9broadcastERNSt6stringEi"], [2, "_CPPv4N5cudaq3mpi9broadcastERNSt6vectorIdEEi"]], "cudaq::mpi::finalize (c++ function)": [[2, "_CPPv4N5cudaq3mpi8finalizeEv"]], "cudaq::mpi::initialize (c++ function)": [[2, "_CPPv4N5cudaq3mpi10initializeEiPPc"], [2, "_CPPv4N5cudaq3mpi10initializeEv"]], "cudaq::mpi::is_initialized (c++ function)": [[2, "_CPPv4N5cudaq3mpi14is_initializedEv"]], "cudaq::mpi::num_ranks (c++ function)": [[2, "_CPPv4N5cudaq3mpi9num_ranksEv"]], "cudaq::mpi::rank (c++ function)": [[2, "_CPPv4N5cudaq3mpi4rankEv"]], "cudaq::noise_model (c++ class)": [[2, "_CPPv4N5cudaq11noise_modelE"]], "cudaq::noise_model::add_channel (c++ function)": [[2, "_CPPv4IDpEN5cudaq11noise_model11add_channelEvRKNSt6vectorINSt6size_tEEERK13kraus_channel"], [2, "_CPPv4N5cudaq11noise_model11add_channelERKNSt6stringERKNSt6vectorINSt6size_tEEERK13kraus_channel"]], "cudaq::noise_model::empty (c++ function)": [[2, "_CPPv4NK5cudaq11noise_model5emptyEv"]], "cudaq::noise_model::get_channels (c++ function)": [[2, "_CPPv4I0ENK5cudaq11noise_model12get_channelsENSt6vectorI13kraus_channelEERKNSt6vectorINSt6size_tEEE"], [2, "_CPPv4NK5cudaq11noise_model12get_channelsERKNSt6stringERKNSt6vectorINSt6size_tEEE"]], "cudaq::noise_model::noise_model (c++ function)": [[2, "_CPPv4N5cudaq11noise_model11noise_modelEv"]], "cudaq::num_available_gpus (c++ function)": [[2, "_CPPv4N5cudaq18num_available_gpusEv"]], "cudaq::observe_result (c++ class)": [[2, "_CPPv4N5cudaq14observe_resultE"]], "cudaq::observe_result::counts (c++ function)": [[2, "_CPPv4I0EN5cudaq14observe_result6countsE13sample_result10SpinOpType"]], "cudaq::observe_result::dump (c++ function)": [[2, "_CPPv4N5cudaq14observe_result4dumpEv"]], "cudaq::observe_result::expectation (c++ function)": [[2, "_CPPv4I0EN5cudaq14observe_result11expectationEd10SpinOpType"], [2, "_CPPv4N5cudaq14observe_result11expectationEv"]], "cudaq::observe_result::id_coefficient (c++ function)": [[2, "_CPPv4N5cudaq14observe_result14id_coefficientEv"]], "cudaq::observe_result::observe_result (c++ function)": [[2, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op"], [2, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op13sample_result"]], "cudaq::observe_result::operator double (c++ function)": [[2, "_CPPv4N5cudaq14observe_resultcvdEv"]], "cudaq::observe_result::raw_data (c++ function)": [[2, "_CPPv4N5cudaq14observe_result8raw_dataEv"]], "cudaq::optimizable_function (c++ class)": [[2, "_CPPv4N5cudaq20optimizable_functionE"]], "cudaq::optimization_result (c++ type)": [[2, "_CPPv4N5cudaq19optimization_resultE"]], "cudaq::optimizer (c++ class)": [[2, "_CPPv4N5cudaq9optimizerE"]], "cudaq::optimizer::optimize (c++ function)": [[2, "_CPPv4N5cudaq9optimizer8optimizeEKiRR20optimizable_function"]], "cudaq::optimizer::requiresgradients (c++ function)": [[2, "_CPPv4N5cudaq9optimizer17requiresGradientsEv"]], "cudaq::phase_flip_channel (c++ class)": [[2, "_CPPv4N5cudaq18phase_flip_channelE"]], "cudaq::qreg (c++ class)": [[2, "_CPPv4I_NSt6size_tE_NSt6size_tE0EN5cudaq4qregE"]], "cudaq::qreg::back (c++ function)": [[2, "_CPPv4N5cudaq4qreg4backENSt6size_tE"], [2, "_CPPv4N5cudaq4qreg4backEv"]], "cudaq::qreg::begin (c++ function)": [[2, "_CPPv4N5cudaq4qreg5beginEv"]], "cudaq::qreg::clear (c++ function)": [[2, "_CPPv4N5cudaq4qreg5clearEv"]], "cudaq::qreg::front (c++ function)": [[2, "_CPPv4N5cudaq4qreg5frontENSt6size_tE"], [2, "_CPPv4N5cudaq4qreg5frontEv"]], "cudaq::qreg::operator[] (c++ function)": [[2, "_CPPv4N5cudaq4qregixEKNSt6size_tE"]], "cudaq::qreg::size (c++ function)": [[2, "_CPPv4NK5cudaq4qreg4sizeEv"]], "cudaq::qreg::slice (c++ function)": [[2, "_CPPv4N5cudaq4qreg5sliceENSt6size_tENSt6size_tE"]], "cudaq::qreg::value_type (c++ type)": [[2, "_CPPv4N5cudaq4qreg10value_typeE"]], "cudaq::qspan (c++ class)": [[2, "_CPPv4I_NSt6size_tE_NSt6size_tEEN5cudaq5qspanE"]], "cudaq::quantum_platform (c++ class)": [[2, "_CPPv4N5cudaq16quantum_platformE"]], "cudaq::quantum_platform::clear_shots (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform11clear_shotsEv"]], "cudaq::quantum_platform::connectivity (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform12connectivityEv"]], "cudaq::quantum_platform::enqueueasynctask (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tER19KernelExecutionTask"], [2, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tERNSt8functionIFvvEEE"]], "cudaq::quantum_platform::getlogstream (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform12getLogStreamEv"]], "cudaq::quantum_platform::get_current_qpu (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform15get_current_qpuEv"]], "cudaq::quantum_platform::get_exec_ctx (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform12get_exec_ctxEv"]], "cudaq::quantum_platform::get_num_qubits (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform14get_num_qubitsENSt6size_tE"], [2, "_CPPv4N5cudaq16quantum_platform14get_num_qubitsEv"]], "cudaq::quantum_platform::get_remote_capabilities (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform23get_remote_capabilitiesEKNSt6size_tE"]], "cudaq::quantum_platform::get_shots (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform9get_shotsEv"]], "cudaq::quantum_platform::is_emulated (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform11is_emulatedEKNSt6size_tE"]], "cudaq::quantum_platform::is_remote (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform9is_remoteEKNSt6size_tE"]], "cudaq::quantum_platform::is_simulator (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform12is_simulatorEKNSt6size_tE"]], "cudaq::quantum_platform::launchvqe (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE"]], "cudaq::quantum_platform::list_platforms (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform14list_platformsEv"]], "cudaq::quantum_platform::name (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform4nameEv"]], "cudaq::quantum_platform::num_qpus (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform8num_qpusEv"]], "cudaq::quantum_platform::onrandomseedset (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform15onRandomSeedSetENSt6size_tE"]], "cudaq::quantum_platform::resetlogstream (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform14resetLogStreamEv"]], "cudaq::quantum_platform::reset_exec_ctx (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform14reset_exec_ctxENSt6size_tE"]], "cudaq::quantum_platform::reset_noise (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform11reset_noiseEv"]], "cudaq::quantum_platform::setlogstream (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform12setLogStreamERNSt7ostreamE"]], "cudaq::quantum_platform::settargetbackend (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform16setTargetBackendERKNSt6stringE"]], "cudaq::quantum_platform::set_current_qpu (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform15set_current_qpuEKNSt6size_tE"]], "cudaq::quantum_platform::set_exec_ctx (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform12set_exec_ctxEPN5cudaq16ExecutionContextENSt6size_tE"]], "cudaq::quantum_platform::set_noise (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform9set_noiseEPK11noise_model"]], "cudaq::quantum_platform::set_shots (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform9set_shotsEi"]], "cudaq::quantum_platform::supports_conditional_feedback (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform29supports_conditional_feedbackEKNSt6size_tE"]], "cudaq::quantum_platform::supports_task_distribution (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform26supports_task_distributionEv"]], "cudaq::qubit (c++ type)": [[2, "_CPPv4N5cudaq5qubitE"]], "cudaq::qudit (c++ class)": [[2, "_CPPv4I_NSt6size_tEEN5cudaq5quditE"]], "cudaq::qudit::qudit (c++ function)": [[2, "_CPPv4N5cudaq5qudit5quditEv"]], "cudaq::qvector (c++ class)": [[2, "_CPPv4I_NSt6size_tEEN5cudaq7qvectorE"]], "cudaq::qvector::back (c++ function)": [[2, "_CPPv4N5cudaq7qvector4backENSt6size_tE"], [2, "_CPPv4N5cudaq7qvector4backEv"]], "cudaq::qvector::begin (c++ function)": [[2, "_CPPv4N5cudaq7qvector5beginEv"]], "cudaq::qvector::clear (c++ function)": [[2, "_CPPv4N5cudaq7qvector5clearEv"]], "cudaq::qvector::end (c++ function)": [[2, "_CPPv4N5cudaq7qvector3endEv"]], "cudaq::qvector::front (c++ function)": [[2, "_CPPv4N5cudaq7qvector5frontENSt6size_tE"], [2, "_CPPv4N5cudaq7qvector5frontEv"]], "cudaq::qvector::operator= (c++ function)": [[2, "_CPPv4N5cudaq7qvectoraSERK7qvector"]], "cudaq::qvector::operator[] (c++ function)": [[2, "_CPPv4N5cudaq7qvectorixEKNSt6size_tE"]], "cudaq::qvector::qvector (c++ function)": [[2, "_CPPv4N5cudaq7qvector7qvectorENSt6size_tE"], [2, "_CPPv4N5cudaq7qvector7qvectorERK5state"], [2, "_CPPv4N5cudaq7qvector7qvectorERK7qvector"], [2, "_CPPv4N5cudaq7qvector7qvectorERKNSt6vectorI7complexEEb"], [2, "_CPPv4N5cudaq7qvector7qvectorERR7qvector"]], "cudaq::qvector::size (c++ function)": [[2, "_CPPv4NK5cudaq7qvector4sizeEv"]], "cudaq::qvector::slice (c++ function)": [[2, "_CPPv4N5cudaq7qvector5sliceENSt6size_tENSt6size_tE"]], "cudaq::qvector::value_type (c++ type)": [[2, "_CPPv4N5cudaq7qvector10value_typeE"]], "cudaq::qview (c++ class)": [[2, "_CPPv4I_NSt6size_tEEN5cudaq5qviewE"]], "cudaq::qview::value_type (c++ type)": [[2, "_CPPv4N5cudaq5qview10value_typeE"]], "cudaq::range (c++ function)": [[2, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType"], [2, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType11ElementType11ElementType"], [2, "_CPPv4N5cudaq5rangeENSt6size_tE"]], "cudaq::real (c++ type)": [[2, "_CPPv4N5cudaq4realE"]], "cudaq::registry (c++ type)": [[2, "_CPPv4N5cudaq8registryE"]], "cudaq::registry::registeredtype (c++ class)": [[2, "_CPPv4I0EN5cudaq8registry14RegisteredTypeE"]], "cudaq::sample_result (c++ class)": [[2, "_CPPv4N5cudaq13sample_resultE"]], "cudaq::sample_result::append (c++ function)": [[2, "_CPPv4N5cudaq13sample_result6appendER15ExecutionResult"]], "cudaq::sample_result::begin (c++ function)": [[2, "_CPPv4N5cudaq13sample_result5beginEv"], [2, "_CPPv4NK5cudaq13sample_result5beginEv"]], "cudaq::sample_result::cbegin (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result6cbeginEv"]], "cudaq::sample_result::cend (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result4cendEv"]], "cudaq::sample_result::clear (c++ function)": [[2, "_CPPv4N5cudaq13sample_result5clearEv"]], "cudaq::sample_result::count (c++ function)": [[2, "_CPPv4N5cudaq13sample_result5countENSt11string_viewEKNSt11string_viewE"]], "cudaq::sample_result::deserialize (c++ function)": [[2, "_CPPv4N5cudaq13sample_result11deserializeERNSt6vectorINSt6size_tEEE"]], "cudaq::sample_result::dump (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result4dumpERNSt7ostreamE"], [2, "_CPPv4NK5cudaq13sample_result4dumpEv"]], "cudaq::sample_result::end (c++ function)": [[2, "_CPPv4N5cudaq13sample_result3endEv"], [2, "_CPPv4NK5cudaq13sample_result3endEv"]], "cudaq::sample_result::exp_val_z (c++ function)": [[2, "_CPPv4N5cudaq13sample_result9exp_val_zEKNSt11string_viewE"]], "cudaq::sample_result::expectation (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result11expectationEKNSt11string_viewE"]], "cudaq::sample_result::get_marginal (c++ function)": [[2, "_CPPv4N5cudaq13sample_result12get_marginalERKNSt6vectorINSt6size_tEEEKNSt11string_viewE"], [2, "_CPPv4N5cudaq13sample_result12get_marginalERRKNSt6vectorINSt6size_tEEEKNSt11string_viewE"]], "cudaq::sample_result::has_even_parity (c++ function)": [[2, "_CPPv4N5cudaq13sample_result15has_even_parityENSt11string_viewE"]], "cudaq::sample_result::has_expectation (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result15has_expectationEKNSt11string_viewE"]], "cudaq::sample_result::most_probable (c++ function)": [[2, "_CPPv4N5cudaq13sample_result13most_probableEKNSt11string_viewE"]], "cudaq::sample_result::operator+= (c++ function)": [[2, "_CPPv4N5cudaq13sample_resultpLERK13sample_result"]], "cudaq::sample_result::operator= (c++ function)": [[2, "_CPPv4N5cudaq13sample_resultaSER13sample_result"]], "cudaq::sample_result::operator== (c++ function)": [[2, "_CPPv4NK5cudaq13sample_resulteqERK13sample_result"]], "cudaq::sample_result::probability (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result11probabilityENSt11string_viewEKNSt11string_viewE"]], "cudaq::sample_result::register_names (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result14register_namesEv"]], "cudaq::sample_result::reorder (c++ function)": [[2, "_CPPv4N5cudaq13sample_result7reorderERKNSt6vectorINSt6size_tEEEKNSt11string_viewE"]], "cudaq::sample_result::sample_result (c++ function)": [[2, "_CPPv4N5cudaq13sample_result13sample_resultER15ExecutionResult"], [2, "_CPPv4N5cudaq13sample_result13sample_resultERK13sample_result"], [2, "_CPPv4N5cudaq13sample_result13sample_resultERNSt6vectorI15ExecutionResultEE"], [2, "_CPPv4N5cudaq13sample_result13sample_resultERR15ExecutionResult"], [2, "_CPPv4N5cudaq13sample_result13sample_resultEdRNSt6vectorI15ExecutionResultEE"], [2, "_CPPv4N5cudaq13sample_result13sample_resultEv"]], "cudaq::sample_result::serialize (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result9serializeEv"]], "cudaq::sample_result::size (c++ function)": [[2, "_CPPv4N5cudaq13sample_result4sizeEKNSt11string_viewE"]], "cudaq::sample_result::to_map (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result6to_mapEKNSt11string_viewE"]], "cudaq::sample_result::~sample_result (c++ function)": [[2, "_CPPv4N5cudaq13sample_resultD0Ev"]], "cudaq::set_noise (c++ function)": [[2, "_CPPv4N5cudaq9set_noiseERKN5cudaq11noise_modelE"]], "cudaq::set_random_seed (c++ function)": [[2, "_CPPv4N5cudaq15set_random_seedENSt6size_tE"]], "cudaq::simulation_precision (c++ enum)": [[2, "_CPPv4N5cudaq20simulation_precisionE"]], "cudaq::simulation_precision::fp32 (c++ enumerator)": [[2, "_CPPv4N5cudaq20simulation_precision4fp32E"]], "cudaq::simulation_precision::fp64 (c++ enumerator)": [[2, "_CPPv4N5cudaq20simulation_precision4fp64E"]], "cudaq::spin_op (c++ class)": [[2, "_CPPv4N5cudaq7spin_opE"]], "cudaq::spin_op::begin (c++ function)": [[2, "_CPPv4N5cudaq7spin_op5beginEv"], [2, "_CPPv4NK5cudaq7spin_op5beginEv"]], "cudaq::spin_op::csr_spmatrix (c++ type)": [[2, "_CPPv4N5cudaq7spin_op12csr_spmatrixE"]], "cudaq::spin_op::distribute_terms (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op16distribute_termsENSt6size_tE"]], "cudaq::spin_op::dump (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op4dumpEv"]], "cudaq::spin_op::end (c++ function)": [[2, "_CPPv4N5cudaq7spin_op3endEv"], [2, "_CPPv4NK5cudaq7spin_op3endEv"]], "cudaq::spin_op::for_each_pauli (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op14for_each_pauliERRNSt8functionIFv5pauliNSt6size_tEEEE"]], "cudaq::spin_op::for_each_term (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op13for_each_termERRNSt8functionIFvR7spin_opEEE"]], "cudaq::spin_op::from_word (c++ function)": [[2, "_CPPv4N5cudaq7spin_op9from_wordERKNSt6stringE"]], "cudaq::spin_op::getdatarepresentation (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op21getDataRepresentationEv"]], "cudaq::spin_op::getdatatuple (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op12getDataTupleEv"]], "cudaq::spin_op::get_coefficient (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op15get_coefficientEv"]], "cudaq::spin_op::get_raw_data (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op12get_raw_dataEv"]], "cudaq::spin_op::is_identity (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op11is_identityEv"]], "cudaq::spin_op::iterator (c++ struct)": [[2, "_CPPv4I0EN5cudaq7spin_op8iteratorE"]], "cudaq::spin_op::num_qubits (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op10num_qubitsEv"]], "cudaq::spin_op::num_terms (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op9num_termsEv"]], "cudaq::spin_op::operator*= (c++ function)": [[2, "_CPPv4N5cudaq7spin_opmLEKNSt7complexIdEE"], [2, "_CPPv4N5cudaq7spin_opmLEKd"], [2, "_CPPv4N5cudaq7spin_opmLERK7spin_op"]], "cudaq::spin_op::operator+= (c++ function)": [[2, "_CPPv4N5cudaq7spin_oppLERK7spin_op"]], "cudaq::spin_op::operator-= (c++ function)": [[2, "_CPPv4N5cudaq7spin_opmIERK7spin_op"]], "cudaq::spin_op::operator= (c++ function)": [[2, "_CPPv4N5cudaq7spin_opaSERK7spin_op"]], "cudaq::spin_op::operator== (c++ function)": [[2, "_CPPv4NK5cudaq7spin_opeqERK7spin_op"]], "cudaq::spin_op::random (c++ function)": [[2, "_CPPv4N5cudaq7spin_op6randomENSt6size_tENSt6size_tEj"]], "cudaq::spin_op::spin_op (c++ function)": [[2, "_CPPv4N5cudaq7spin_op7spin_opE5pauliKNSt6size_tENSt7complexIdEE"], [2, "_CPPv4N5cudaq7spin_op7spin_opENSt6size_tE"], [2, "_CPPv4N5cudaq7spin_op7spin_opERK12spin_op_termRKNSt7complexIdEE"], [2, "_CPPv4N5cudaq7spin_op7spin_opERK7spin_op"], [2, "_CPPv4N5cudaq7spin_op7spin_opERKNSt13unordered_mapI12spin_op_termNSt7complexIdEEEE"], [2, "_CPPv4N5cudaq7spin_op7spin_opERKNSt4pairIK12spin_op_termNSt7complexIdEEEE"], [2, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorI12spin_op_termEERKNSt6vectorINSt7complexIdEEEE"], [2, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorIdEENSt6size_tE"], [2, "_CPPv4N5cudaq7spin_op7spin_opERNSt4pairIK12spin_op_termNSt7complexIdEEEE"], [2, "_CPPv4N5cudaq7spin_op7spin_opEv"]], "cudaq::spin_op::spin_op_term (c++ type)": [[2, "_CPPv4N5cudaq7spin_op12spin_op_termE"]], "cudaq::spin_op::to_matrix (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op9to_matrixEv"]], "cudaq::spin_op::to_sparse_matrix (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op16to_sparse_matrixEv"]], "cudaq::spin_op::to_string (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op9to_stringEb"]], "cudaq::spin_op::~spin_op (c++ function)": [[2, "_CPPv4N5cudaq7spin_opD0Ev"]], "cudaq::state (c++ class)": [[2, "_CPPv4N5cudaq5stateE"]], "cudaq::state::amplitude (c++ function)": [[2, "_CPPv4N5cudaq5state9amplitudeERKNSt6vectorIiEE"]], "cudaq::state::amplitudes (c++ function)": [[2, "_CPPv4N5cudaq5state10amplitudesERKNSt6vectorINSt6vectorIiEEEE"]], "cudaq::state::dump (c++ function)": [[2, "_CPPv4NK5cudaq5state4dumpERNSt7ostreamE"], [2, "_CPPv4NK5cudaq5state4dumpEv"]], "cudaq::state::from_data (c++ function)": [[2, "_CPPv4N5cudaq5state9from_dataERK10state_data"]], "cudaq::state::get_num_qubits (c++ function)": [[2, "_CPPv4NK5cudaq5state14get_num_qubitsEv"]], "cudaq::state::get_num_tensors (c++ function)": [[2, "_CPPv4NK5cudaq5state15get_num_tensorsEv"]], "cudaq::state::get_precision (c++ function)": [[2, "_CPPv4NK5cudaq5state13get_precisionEv"]], "cudaq::state::get_tensor (c++ function)": [[2, "_CPPv4NK5cudaq5state10get_tensorENSt6size_tE"]], "cudaq::state::get_tensors (c++ function)": [[2, "_CPPv4NK5cudaq5state11get_tensorsEv"]], "cudaq::state::is_on_gpu (c++ function)": [[2, "_CPPv4NK5cudaq5state9is_on_gpuEv"]], "cudaq::state::operator() (c++ function)": [[2, "_CPPv4N5cudaq5stateclENSt6size_tENSt6size_tE"], [2, "_CPPv4N5cudaq5stateclERKNSt16initializer_listINSt6size_tEEENSt6size_tE"]], "cudaq::state::operator= (c++ function)": [[2, "_CPPv4N5cudaq5stateaSERR5state"]], "cudaq::state::operator[] (c++ function)": [[2, "_CPPv4N5cudaq5stateixENSt6size_tE"]], "cudaq::state::overlap (c++ function)": [[2, "_CPPv4N5cudaq5state7overlapERK5state"]], "cudaq::state::state (c++ function)": [[2, "_CPPv4N5cudaq5state5stateEP15SimulationState"], [2, "_CPPv4N5cudaq5state5stateERK5state"]], "cudaq::state::to_host (c++ function)": [[2, "_CPPv4I0ENK5cudaq5state7to_hostEvPNSt7complexI10ScalarTypeEENSt6size_tE"]], "cudaq::state_data (c++ type)": [[2, "_CPPv4N5cudaq10state_dataE"]], "cudaq::tensor (c++ type)": [[2, "_CPPv4N5cudaq6tensorE"]], "cudaq::unset_noise (c++ function)": [[2, "_CPPv4N5cudaq11unset_noiseEv"]], "nvqir::mpssimulationstate (c++ class)": [[2, "_CPPv4N5nvqir18MPSSimulationStateE"]], "nvqir::tensornetsimulationstate (c++ class)": [[2, "_CPPv4N5nvqir24TensorNetSimulationStateE"]], "amplitudedampingchannel (class in cudaq)": [[3, "cudaq.AmplitudeDampingChannel"]], "asyncobserveresult (class in cudaq)": [[3, "cudaq.AsyncObserveResult"]], "asyncsampleresult (class in cudaq)": [[3, "cudaq.AsyncSampleResult"]], "asyncstateresult (class in cudaq)": [[3, "cudaq.AsyncStateResult"]], "bitflipchannel (class in cudaq)": [[3, "cudaq.BitFlipChannel"]], "cobyla (class in cudaq.optimizers)": [[3, "cudaq.optimizers.COBYLA"]], "centraldifference (class in cudaq.gradients)": [[3, "cudaq.gradients.CentralDifference"]], "complexmatrix (class in cudaq)": [[3, "cudaq.ComplexMatrix"]], "depolarizationchannel (class in cudaq)": [[3, "cudaq.DepolarizationChannel"]], "forwarddifference (class in cudaq.gradients)": [[3, "cudaq.gradients.ForwardDifference"]], "gradientdescent (class in cudaq.optimizers)": [[3, "cudaq.optimizers.GradientDescent"]], "kernel (in module cudaq)": [[3, "cudaq.Kernel"]], "krauschannel (class in cudaq)": [[3, "cudaq.KrausChannel"]], "krausoperator (class in cudaq)": [[3, "cudaq.KrausOperator"]], "lbfgs (class in cudaq.optimizers)": [[3, "cudaq.optimizers.LBFGS"]], "neldermead (class in cudaq.optimizers)": [[3, "cudaq.optimizers.NelderMead"]], "noisemodel (class in cudaq)": [[3, "cudaq.NoiseModel"]], "observeresult (class in cudaq)": [[3, "cudaq.ObserveResult"]], "optimizationresult (class in cudaq)": [[3, "cudaq.OptimizationResult"]], "parametershift (class in cudaq.gradients)": [[3, "cudaq.gradients.ParameterShift"]], "phaseflipchannel (class in cudaq)": [[3, "cudaq.PhaseFlipChannel"]], "pykernel (class in cudaq)": [[3, "cudaq.PyKernel"]], "pykerneldecorator (class in cudaq)": [[3, "cudaq.PyKernelDecorator"]], "quakevalue (class in cudaq)": [[3, "cudaq.QuakeValue"]], "sampleresult (class in cudaq)": [[3, "cudaq.SampleResult"]], "simulationprecision (class in cudaq)": [[3, "cudaq.SimulationPrecision"]], "spinoperator (class in cudaq)": [[3, "cudaq.SpinOperator"]], "state (class in cudaq)": [[3, "cudaq.State"]], "target (class in cudaq)": [[3, "cudaq.Target"]], "tensor (class in cudaq)": [[3, "cudaq.Tensor"]], "__add__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__add__"]], "__add__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__add__"]], "__call__() (cudaq.pykerneldecorator method)": [[3, "cudaq.PyKernelDecorator.__call__"]], "__eq__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__eq__"]], "__getitem__() (cudaq.complexmatrix method)": [[3, "cudaq.ComplexMatrix.__getitem__"]], "__getitem__() (cudaq.krauschannel method)": [[3, "cudaq.KrausChannel.__getitem__"]], "__getitem__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__getitem__"]], "__getitem__() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.__getitem__"]], "__init__() (cudaq.amplitudedampingchannel method)": [[3, "cudaq.AmplitudeDampingChannel.__init__"]], "__init__() (cudaq.bitflipchannel method)": [[3, "cudaq.BitFlipChannel.__init__"]], "__init__() (cudaq.depolarizationchannel method)": [[3, "cudaq.DepolarizationChannel.__init__"]], "__init__() (cudaq.noisemodel method)": [[3, "cudaq.NoiseModel.__init__"]], "__init__() (cudaq.phaseflipchannel method)": [[3, "cudaq.PhaseFlipChannel.__init__"]], "__iter__() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.__iter__"]], "__iter__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__iter__"]], "__len__() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.__len__"]], "__mul__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__mul__"]], "__mul__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__mul__"]], "__neg__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__neg__"]], "__radd__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__radd__"]], "__radd__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__radd__"]], "__rmul__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__rmul__"]], "__rmul__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__rmul__"]], "__rsub__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__rsub__"]], "__rsub__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__rsub__"]], "__str__() (cudaq.complexmatrix method)": [[3, "cudaq.ComplexMatrix.__str__"]], "__str__() (cudaq.pykerneldecorator method)": [[3, "cudaq.PyKernelDecorator.__str__"]], "__sub__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__sub__"]], "__sub__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__sub__"]], "add_channel() (cudaq.noisemodel method)": [[3, "cudaq.NoiseModel.add_channel"]], "all_gather() (in module cudaq.mpi)": [[3, "cudaq.mpi.all_gather"]], "amplitude() (cudaq.state method)": [[3, "cudaq.State.amplitude"]], "amplitudes() (cudaq.state method)": [[3, "cudaq.State.amplitudes"]], "append() (cudaq.krauschannel method)": [[3, "cudaq.KrausChannel.append"]], "argument_count (cudaq.pykernel attribute)": [[3, "cudaq.PyKernel.argument_count"]], "arguments (cudaq.pykernel attribute)": [[3, "cudaq.PyKernel.arguments"]], "broadcast() (in module cudaq.mpi)": [[3, "cudaq.mpi.broadcast"]], "clear() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.clear"]], "col_count (cudaq.krausoperator property)": [[3, "cudaq.KrausOperator.col_count"]], "compile() (cudaq.pykerneldecorator method)": [[3, "cudaq.PyKernelDecorator.compile"]], "compute() (cudaq.gradients.centraldifference method)": [[3, "cudaq.gradients.CentralDifference.compute"]], "compute() (cudaq.gradients.forwarddifference method)": [[3, "cudaq.gradients.ForwardDifference.compute"]], "compute() (cudaq.gradients.parametershift method)": [[3, "cudaq.gradients.ParameterShift.compute"]], "count() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.count"]], "counts() (cudaq.observeresult method)": [[3, "cudaq.ObserveResult.counts"]], "cudaq": [[3, "module-cudaq"]], "description (cudaq.target property)": [[3, "cudaq.Target.description"]], "distribute_terms() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.distribute_terms"]], "draw() (in module cudaq)": [[3, "cudaq.draw"]], "dump() (cudaq.observeresult method)": [[3, "cudaq.ObserveResult.dump"]], "dump() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.dump"]], "dump() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.dump"]], "dump() (cudaq.state method)": [[3, "cudaq.State.dump"]], "expectation() (cudaq.observeresult method)": [[3, "cudaq.ObserveResult.expectation"]], "expectation() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.expectation"]], "expectation_z() (cudaq.observeresult method)": [[3, "cudaq.ObserveResult.expectation_z"]], "expectation_z() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.expectation_z"]], "finalize() (in module cudaq.mpi)": [[3, "cudaq.mpi.finalize"]], "for_each_pauli() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.for_each_pauli"]], "for_each_term() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.for_each_term"]], "from_data() (cudaq.state static method)": [[3, "cudaq.State.from_data"]], "from_json() (cudaq.pykerneldecorator static method)": [[3, "cudaq.PyKernelDecorator.from_json"]], "from_json() (cudaq.spinoperator static method)": [[3, "cudaq.SpinOperator.from_json"]], "from_json() (cudaq.gradients.centraldifference static method)": [[3, "cudaq.gradients.CentralDifference.from_json"]], "from_json() (cudaq.gradients.forwarddifference static method)": [[3, "cudaq.gradients.ForwardDifference.from_json"]], "from_json() (cudaq.gradients.parametershift static method)": [[3, "cudaq.gradients.ParameterShift.from_json"]], "from_json() (cudaq.optimizers.cobyla static method)": [[3, "cudaq.optimizers.COBYLA.from_json"]], "from_json() (cudaq.optimizers.gradientdescent static method)": [[3, "cudaq.optimizers.GradientDescent.from_json"]], "from_json() (cudaq.optimizers.lbfgs static method)": [[3, "cudaq.optimizers.LBFGS.from_json"]], "from_json() (cudaq.optimizers.neldermead static method)": [[3, "cudaq.optimizers.NelderMead.from_json"]], "from_word() (cudaq.spinoperator static method)": [[3, "cudaq.SpinOperator.from_word"]], "get() (cudaq.asyncobserveresult method)": [[3, "cudaq.AsyncObserveResult.get"]], "get() (cudaq.asyncsampleresult method)": [[3, "cudaq.AsyncSampleResult.get"]], "get() (cudaq.asyncstateresult method)": [[3, "cudaq.AsyncStateResult.get"]], "gettensor() (cudaq.state method)": [[3, "cudaq.State.getTensor"]], "gettensors() (cudaq.state method)": [[3, "cudaq.State.getTensors"]], "get_channels() (cudaq.noisemodel method)": [[3, "cudaq.NoiseModel.get_channels"]], "get_coefficient() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.get_coefficient"]], "get_marginal_counts() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.get_marginal_counts"]], "get_precision() (cudaq.target method)": [[3, "cudaq.Target.get_precision"]], "get_qubit_count() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.get_qubit_count"]], "get_raw_data() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.get_raw_data"]], "get_register_counts() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.get_register_counts"]], "get_sequential_data() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.get_sequential_data"]], "get_spin() (cudaq.observeresult method)": [[3, "cudaq.ObserveResult.get_spin"]], "get_state() (in module cudaq)": [[3, "cudaq.get_state"]], "get_state_async() (in module cudaq)": [[3, "cudaq.get_state_async"]], "get_target() (in module cudaq)": [[3, "cudaq.get_target"]], "get_targets() (in module cudaq)": [[3, "cudaq.get_targets"]], "get_term_count() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.get_term_count"]], "gradient (class in cudaq.gradients)": [[3, "cudaq.gradients.gradient"]], "has_target() (in module cudaq)": [[3, "cudaq.has_target"]], "initial_parameters (cudaq.optimizers.cobyla property)": [[3, "cudaq.optimizers.COBYLA.initial_parameters"]], "initial_parameters (cudaq.optimizers.gradientdescent property)": [[3, "cudaq.optimizers.GradientDescent.initial_parameters"]], "initial_parameters (cudaq.optimizers.lbfgs property)": [[3, "cudaq.optimizers.LBFGS.initial_parameters"]], "initial_parameters (cudaq.optimizers.neldermead property)": [[3, "cudaq.optimizers.NelderMead.initial_parameters"]], "initialize() (in module cudaq.mpi)": [[3, "cudaq.mpi.initialize"]], "initialize_cudaq() (in module cudaq)": [[3, "cudaq.initialize_cudaq"]], "is_emulated() (cudaq.target method)": [[3, "cudaq.Target.is_emulated"]], "is_identity() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.is_identity"]], "is_initialized() (in module cudaq.mpi)": [[3, "cudaq.mpi.is_initialized"]], "is_on_gpu() (cudaq.state method)": [[3, "cudaq.State.is_on_gpu"]], "is_remote() (cudaq.target method)": [[3, "cudaq.Target.is_remote"]], "items() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.items"]], "kernel() (in module cudaq)": [[3, "cudaq.kernel"]], "lower_bounds (cudaq.optimizers.cobyla property)": [[3, "cudaq.optimizers.COBYLA.lower_bounds"]], "lower_bounds (cudaq.optimizers.gradientdescent property)": [[3, "cudaq.optimizers.GradientDescent.lower_bounds"]], "lower_bounds (cudaq.optimizers.lbfgs property)": [[3, "cudaq.optimizers.LBFGS.lower_bounds"]], "lower_bounds (cudaq.optimizers.neldermead property)": [[3, "cudaq.optimizers.NelderMead.lower_bounds"]], "make_kernel() (in module cudaq)": [[3, "cudaq.make_kernel"]], "max_iterations (cudaq.optimizers.cobyla property)": [[3, "cudaq.optimizers.COBYLA.max_iterations"]], "max_iterations (cudaq.optimizers.gradientdescent property)": [[3, "cudaq.optimizers.GradientDescent.max_iterations"]], "max_iterations (cudaq.optimizers.lbfgs property)": [[3, "cudaq.optimizers.LBFGS.max_iterations"]], "max_iterations (cudaq.optimizers.neldermead property)": [[3, "cudaq.optimizers.NelderMead.max_iterations"]], "minimal_eigenvalue() (cudaq.complexmatrix method)": [[3, "cudaq.ComplexMatrix.minimal_eigenvalue"]], "module": [[3, "module-cudaq"]], "most_probable() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.most_probable"]], "name (cudaq.pykernel attribute)": [[3, "cudaq.PyKernel.name"]], "name (cudaq.simulationprecision property)": [[3, "cudaq.SimulationPrecision.name"]], "name (cudaq.target property)": [[3, "cudaq.Target.name"]], "num_available_gpus() (in module cudaq)": [[3, "cudaq.num_available_gpus"]], "num_qpus() (cudaq.target method)": [[3, "cudaq.Target.num_qpus"]], "num_qubits() (cudaq.state method)": [[3, "cudaq.State.num_qubits"]], "num_ranks() (in module cudaq.mpi)": [[3, "cudaq.mpi.num_ranks"]], "observe() (in module cudaq)": [[3, "cudaq.observe"]], "observe_async() (in module cudaq)": [[3, "cudaq.observe_async"]], "optimize() (cudaq.optimizers.cobyla method)": [[3, "cudaq.optimizers.COBYLA.optimize"]], "optimize() (cudaq.optimizers.gradientdescent method)": [[3, "cudaq.optimizers.GradientDescent.optimize"]], "optimize() (cudaq.optimizers.lbfgs method)": [[3, "cudaq.optimizers.LBFGS.optimize"]], "optimize() (cudaq.optimizers.neldermead method)": [[3, "cudaq.optimizers.NelderMead.optimize"]], "optimizer (class in cudaq.optimizers)": [[3, "cudaq.optimizers.optimizer"]], "overlap() (cudaq.state method)": [[3, "cudaq.State.overlap"]], "platform (cudaq.target property)": [[3, "cudaq.Target.platform"]], "probability() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.probability"]], "qreg (in module cudaq)": [[3, "cudaq.qreg"]], "qubit (class in cudaq)": [[3, "cudaq.qubit"]], "qvector (class in cudaq)": [[3, "cudaq.qvector"]], "random() (cudaq.spinoperator static method)": [[3, "cudaq.SpinOperator.random"]], "rank() (in module cudaq.mpi)": [[3, "cudaq.mpi.rank"]], "register_names (cudaq.sampleresult attribute)": [[3, "cudaq.SampleResult.register_names"]], "requires_gradients() (cudaq.optimizers.cobyla method)": [[3, "cudaq.optimizers.COBYLA.requires_gradients"]], "requires_gradients() (cudaq.optimizers.gradientdescent method)": [[3, "cudaq.optimizers.GradientDescent.requires_gradients"]], "requires_gradients() (cudaq.optimizers.lbfgs method)": [[3, "cudaq.optimizers.LBFGS.requires_gradients"]], "requires_gradients() (cudaq.optimizers.neldermead method)": [[3, "cudaq.optimizers.NelderMead.requires_gradients"]], "reset_target() (in module cudaq)": [[3, "cudaq.reset_target"]], "row_count (cudaq.krausoperator property)": [[3, "cudaq.KrausOperator.row_count"]], "sample() (in module cudaq)": [[3, "cudaq.sample"]], "sample_async() (in module cudaq)": [[3, "cudaq.sample_async"]], "serialize() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.serialize"]], "set_noise() (in module cudaq)": [[3, "cudaq.set_noise"]], "set_random_seed() (in module cudaq)": [[3, "cudaq.set_random_seed"]], "set_target() (in module cudaq)": [[3, "cudaq.set_target"]], "simulator (cudaq.target property)": [[3, "cudaq.Target.simulator"]], "slice() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.slice"]], "spin.i() (in module cudaq)": [[3, "cudaq.spin.i"]], "spin.x() (in module cudaq)": [[3, "cudaq.spin.x"]], "spin.y() (in module cudaq)": [[3, "cudaq.spin.y"]], "spin.z() (in module cudaq)": [[3, "cudaq.spin.z"]], "to_json() (cudaq.pykerneldecorator method)": [[3, "cudaq.PyKernelDecorator.to_json"]], "to_json() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.to_json"]], "to_json() (cudaq.gradients.centraldifference method)": [[3, "cudaq.gradients.CentralDifference.to_json"]], "to_json() (cudaq.gradients.forwarddifference method)": [[3, "cudaq.gradients.ForwardDifference.to_json"]], "to_json() (cudaq.gradients.parametershift method)": [[3, "cudaq.gradients.ParameterShift.to_json"]], "to_json() (cudaq.optimizers.cobyla method)": [[3, "cudaq.optimizers.COBYLA.to_json"]], "to_json() (cudaq.optimizers.gradientdescent method)": [[3, "cudaq.optimizers.GradientDescent.to_json"]], "to_json() (cudaq.optimizers.lbfgs method)": [[3, "cudaq.optimizers.LBFGS.to_json"]], "to_json() (cudaq.optimizers.neldermead method)": [[3, "cudaq.optimizers.NelderMead.to_json"]], "to_matrix() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.to_matrix"]], "to_sparse_matrix() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.to_sparse_matrix"]], "to_string() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.to_string"]], "translate() (in module cudaq)": [[3, "cudaq.translate"]], "type_to_str() (cudaq.pykerneldecorator static method)": [[3, "cudaq.PyKernelDecorator.type_to_str"]], "unset_noise() (in module cudaq)": [[3, "cudaq.unset_noise"]], "upper_bounds (cudaq.optimizers.cobyla property)": [[3, "cudaq.optimizers.COBYLA.upper_bounds"]], "upper_bounds (cudaq.optimizers.gradientdescent property)": [[3, "cudaq.optimizers.GradientDescent.upper_bounds"]], "upper_bounds (cudaq.optimizers.lbfgs property)": [[3, "cudaq.optimizers.LBFGS.upper_bounds"]], "upper_bounds (cudaq.optimizers.neldermead property)": [[3, "cudaq.optimizers.NelderMead.upper_bounds"]], "values() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.values"]], "vqe() (in module cudaq)": [[3, "cudaq.vqe"]]}}) \ No newline at end of file +Search.setIndex({"docnames": ["api/api", "api/default_ops", "api/languages/cpp_api", "api/languages/python_api", "examples/python/tutorials/Divisive_clustering", "examples/python/tutorials/cost_minimization", "examples/python/tutorials/deutschs_algorithm", "examples/python/tutorials/hadamard_test", "examples/python/tutorials/hybrid_qnns", "examples/python/tutorials/maximum_vertex_weight_clique", "examples/python/tutorials/noisy_simulations", "examples/python/tutorials/qaoa", "examples/python/tutorials/quantum_fourier_transform", "examples/python/tutorials/readout_error_mitigation", "examples/python/tutorials/visualization", "examples/python/tutorials/vqe", "examples/python/tutorials/vqe_water_active_space", "index", "releases", "specification/cudaq", "specification/cudaq/algorithmic_primitives", "specification/cudaq/control_flow", "specification/cudaq/dynamic_kernels", "specification/cudaq/examples", "specification/cudaq/kernels", "specification/cudaq/machine_model", "specification/cudaq/namespace", "specification/cudaq/operations", "specification/cudaq/operators", "specification/cudaq/patterns", "specification/cudaq/platform", "specification/cudaq/synthesis", "specification/cudaq/types", "specification/index", "specification/quake-dialect", "using/backends/backends", "using/backends/hardware", "using/backends/nvqc", "using/backends/platform", "using/backends/simulators", "using/basics/basics", "using/basics/build_kernel", "using/basics/kernel_intro", "using/basics/run_kernel", "using/basics/troubleshooting", "using/examples/bernstein_vazirani", "using/examples/cuquantum", "using/examples/examples", "using/examples/expectation_values", "using/examples/hardware_providers", "using/examples/introduction", "using/examples/multi_control", "using/examples/multi_gpu_workflows", "using/examples/noisy_simulation", "using/examples/qaoa", "using/examples/quantum_operations", "using/examples/vqe", "using/extending/cudaq_ir", "using/extending/extending", "using/extending/mlir_pass", "using/extending/nvqir_simulator", "using/install/data_center_install", "using/install/install", "using/install/local_installation", "using/integration/cmake_app", "using/integration/cuda_gpu", "using/integration/integration", "using/integration/libraries", "using/quick_start", "using/tutorials", "versions"], "filenames": ["api/api.rst", "api/default_ops.rst", "api/languages/cpp_api.rst", "api/languages/python_api.rst", "examples/python/tutorials/Divisive_clustering.ipynb", "examples/python/tutorials/cost_minimization.ipynb", "examples/python/tutorials/deutschs_algorithm.ipynb", "examples/python/tutorials/hadamard_test.ipynb", "examples/python/tutorials/hybrid_qnns.ipynb", "examples/python/tutorials/maximum_vertex_weight_clique.ipynb", "examples/python/tutorials/noisy_simulations.ipynb", "examples/python/tutorials/qaoa.ipynb", "examples/python/tutorials/quantum_fourier_transform.ipynb", "examples/python/tutorials/readout_error_mitigation.ipynb", "examples/python/tutorials/visualization.ipynb", "examples/python/tutorials/vqe.ipynb", "examples/python/tutorials/vqe_water_active_space.ipynb", "index.rst", "releases.rst", "specification/cudaq.rst", "specification/cudaq/algorithmic_primitives.rst", "specification/cudaq/control_flow.rst", "specification/cudaq/dynamic_kernels.rst", "specification/cudaq/examples.rst", "specification/cudaq/kernels.rst", "specification/cudaq/machine_model.rst", "specification/cudaq/namespace.rst", "specification/cudaq/operations.rst", "specification/cudaq/operators.rst", "specification/cudaq/patterns.rst", "specification/cudaq/platform.rst", "specification/cudaq/synthesis.rst", "specification/cudaq/types.rst", "specification/index.rst", "specification/quake-dialect.md", "using/backends/backends.rst", "using/backends/hardware.rst", "using/backends/nvqc.rst", "using/backends/platform.rst", "using/backends/simulators.rst", "using/basics/basics.rst", "using/basics/build_kernel.rst", "using/basics/kernel_intro.rst", "using/basics/run_kernel.rst", "using/basics/troubleshooting.rst", "using/examples/bernstein_vazirani.rst", "using/examples/cuquantum.rst", "using/examples/examples.rst", "using/examples/expectation_values.rst", "using/examples/hardware_providers.rst", "using/examples/introduction.rst", "using/examples/multi_control.rst", "using/examples/multi_gpu_workflows.rst", "using/examples/noisy_simulation.rst", "using/examples/qaoa.rst", "using/examples/quantum_operations.rst", "using/examples/vqe.rst", "using/extending/cudaq_ir.rst", "using/extending/extending.rst", "using/extending/mlir_pass.rst", "using/extending/nvqir_simulator.rst", "using/install/data_center_install.rst", "using/install/install.rst", "using/install/local_installation.rst", "using/integration/cmake_app.rst", "using/integration/cuda_gpu.rst", "using/integration/integration.rst", "using/integration/libraries.rst", "using/quick_start.rst", "using/tutorials.rst", "versions.rst"], "titles": ["Code documentation", "Quantum Operations", "CUDA-Q C++ API", "CUDA-Q Python API", "Divisive Clustering With Coresets Using CUDA-Q", "Cost Minimization", "Deutsch\u2019s Algorithm", "Hadamard Test", "Hybrid Quantum Neural Networks", "Molecular docking via DC-QAOA", "Noisy Simulation", "Max-Cut with QAOA", "Quantum Fourier Transform", "Readout Error Mitigation", "Visualization", "Variational Quantum Eigensolver", "Water Molecule with Active Space (CPU vs. GPU)", "CUDA-Q", "CUDA-Q Releases", "Language Specification", "12. Quantum Algorithmic Primitives", "8. Control Flow", "9. Just-in-Time Kernel Creation", "13. Example Programs", "6. Quantum Kernels", "1. Machine Model", "2. Namespace and Standard", "5. Quantum Intrinsic Operations", "4. Quantum Operators", "10. Common Quantum Programming Patterns", "11. Quantum Platform", "7. Sub-circuit Synthesis", "3. Quantum Types", "Specifications", "Quake Dialect", "CUDA-Q Backends", "CUDA-Q Hardware Backends", "NVIDIA Quantum Cloud", "Multi-Processor Platforms", "CUDA-Q Simulation Backends", "CUDA-Q Basics", "Building your first CUDA-Q Program", "What is a CUDA-Q kernel?", "Running your first CUDA-Q Program", "Troubleshooting", "Bernstein-Vazirani", "Simulations with cuQuantum", "CUDA-Q by Example", "Computing Expectation Values", "Using Quantum Hardware Providers", "Introduction", "Multi-control Synthesis", "Multi-GPU Workflows", "Noisy Simulation", "Quantum Approximate Optimization Algorithm", "Quantum Computing 101", "Variational Quantum Eigensolver", "Working with the CUDA-Q IR", "Extending CUDA-Q", "Create your own CUDA-Q Compiler Pass", "Extending CUDA-Q with a new Simulator", "Installation from Source", "Installation Guide", "Local Installation", "CUDA-Q and CMake", "Using CUDA and CUDA-Q in a Project", "Integration with other Software Tools", "Integrating with Third-Party Libraries", "Quick Start", "CUDA-Q Tutorials", "CUDA-Q Versions"], "terms": {"c": [0, 1, 4, 11, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 31, 32, 37, 38, 39, 41, 43, 44, 45, 46, 47, 48, 49, 50, 51, 53, 54, 55, 56, 57, 63, 64, 65, 68, 70], "python": [0, 1, 2, 4, 14, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 28, 29, 31, 32, 37, 38, 39, 41, 43, 44, 45, 46, 47, 48, 49, 50, 51, 53, 54, 56, 60, 67, 68, 69, 70], "quantum": [0, 3, 7, 10, 11, 13, 14, 16, 17, 18, 19, 21, 22, 25, 31, 33, 34, 35, 36, 39, 41, 42, 43, 46, 47, 48, 50, 52, 53, 57, 60, 61, 63, 64, 65, 67, 68, 70], "oper": [0, 3, 4, 6, 7, 8, 9, 10, 11, 12, 14, 17, 19, 20, 22, 23, 24, 25, 29, 31, 32, 33, 34, 36, 37, 39, 41, 43, 46, 47, 48, 49, 50, 51, 53, 54, 55, 56, 57, 59, 60, 61, 63, 68], "cuda": [1, 5, 6, 8, 9, 10, 11, 12, 14, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 37, 38, 44, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 66], "q": [1, 5, 6, 7, 8, 10, 11, 12, 14, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 37, 38, 44, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 66], "provid": [1, 2, 3, 4, 10, 12, 13, 15, 17, 19, 20, 22, 25, 27, 28, 30, 31, 32, 34, 36, 37, 38, 39, 42, 46, 47, 48, 50, 51, 53, 56, 57, 59, 60, 61, 63, 64, 67], "default": [1, 2, 3, 9, 14, 20, 24, 27, 32, 36, 37, 38, 43, 46, 49, 50, 56, 57, 60, 61, 63, 65, 67, 68], "set": [1, 2, 3, 4, 5, 6, 8, 11, 13, 14, 17, 20, 22, 24, 27, 34, 37, 38, 39, 41, 43, 45, 46, 49, 53, 54, 56, 61, 63, 67, 68], "These": [1, 2, 10, 11, 19, 24, 27, 31, 32, 34, 35, 37, 38, 39, 57, 61, 63], "can": [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 18, 20, 21, 22, 23, 24, 25, 27, 28, 29, 30, 31, 32, 34, 35, 36, 37, 38, 39, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 59, 60, 61, 63, 64, 65, 66, 67, 68, 70], "us": [1, 2, 3, 5, 6, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 20, 21, 22, 23, 24, 27, 28, 30, 31, 34, 36, 37, 38, 39, 41, 42, 43, 45, 47, 48, 50, 52, 54, 55, 56, 57, 59, 60, 61, 64, 67, 68, 70], "kernel": [1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 19, 20, 21, 23, 25, 27, 28, 29, 30, 31, 32, 33, 36, 37, 39, 40, 41, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 67, 68, 70], "librari": [1, 2, 8, 9, 14, 15, 17, 18, 19, 24, 26, 31, 32, 39, 48, 57, 59, 60, 63, 65, 66, 70], "sinc": [1, 2, 6, 11, 12, 13, 32, 35, 38, 39, 42, 48, 49, 52, 56, 57, 63, 64, 67], "intrins": [1, 24, 31, 32, 34], "nativ": [1, 19, 25, 27, 28, 64], "support": [1, 2, 3, 13, 14, 17, 18, 19, 24, 25, 27, 29, 32, 36, 42, 43, 46, 49, 50, 53, 54, 55, 56, 59, 67, 68, 70], "specif": [1, 2, 3, 4, 17, 20, 24, 26, 27, 28, 29, 32, 34, 36, 37, 38, 39, 42, 43, 50, 55, 57, 60, 61, 63, 65, 67], "target": [1, 2, 3, 4, 6, 7, 8, 10, 11, 14, 16, 18, 20, 27, 30, 34, 36, 37, 38, 39, 43, 45, 46, 48, 49, 51, 53, 55, 57, 59, 60, 61, 63, 68, 70], "depend": [1, 3, 4, 6, 11, 20, 25, 34, 37, 38, 39, 45, 56, 67, 68], "backend": [1, 2, 4, 5, 17, 18, 20, 38, 43, 45, 46, 49, 52, 53, 57, 60, 61, 63, 67, 68, 70], "architectur": [1, 2, 8, 17, 19, 25, 34, 36, 38, 49, 52, 55, 60, 61, 63, 68], "nvq": [1, 20, 23, 36, 37, 38, 39, 43, 46, 48, 49, 50, 51, 53, 56, 57, 60, 63, 64, 65, 67, 68], "compil": [1, 2, 3, 4, 19, 20, 23, 24, 25, 29, 31, 32, 36, 37, 38, 39, 43, 46, 48, 49, 50, 51, 53, 56, 57, 60, 61, 63, 64, 65, 68], "automat": [1, 25, 36, 38, 39, 49, 56, 61, 63, 67], "decompos": 1, "appropri": [1, 2, 4, 6, 12, 19, 27, 38, 61, 63], "The": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 18, 19, 20, 22, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 43, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 59, 60, 61, 63, 65, 67, 68, 70], "section": [1, 6, 12, 22, 38, 39, 61, 63, 67, 68], "list": [1, 2, 3, 4, 5, 6, 8, 9, 11, 12, 13, 14, 15, 16, 18, 20, 24, 35, 36, 37, 39, 45, 49, 52, 54, 55, 56, 61, 63, 67, 68, 70], "implement": [1, 2, 3, 6, 10, 11, 12, 19, 20, 25, 26, 27, 29, 31, 32, 34, 36, 39, 49, 50, 54, 57, 59, 60, 61, 63, 67], "transform": [1, 6, 8, 16, 17, 19, 23, 57, 59], "state": [1, 2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 18, 20, 24, 25, 27, 32, 34, 37, 41, 43, 45, 46, 48, 49, 50, 52, 53, 54, 56, 60, 61, 67, 68, 70], "ar": [1, 2, 3, 4, 6, 9, 10, 11, 12, 13, 14, 15, 17, 18, 19, 20, 21, 22, 24, 25, 27, 29, 31, 32, 33, 34, 36, 37, 38, 39, 42, 43, 47, 48, 49, 50, 52, 55, 56, 57, 60, 61, 63, 65, 67, 68, 70], "templat": [1, 2, 15, 20, 22, 23, 24, 27, 31, 32, 49, 50, 57, 59, 60, 65, 67], "argument": [1, 2, 3, 4, 6, 11, 13, 14, 20, 22, 24, 31, 32, 36, 41, 43, 48, 51, 52, 56, 57, 60, 63, 67], "allow": [1, 2, 3, 4, 5, 6, 8, 18, 20, 22, 24, 25, 39, 41, 42, 43, 51, 52, 53, 55, 56, 57, 59, 63, 64, 70], "invok": [1, 2, 3, 20, 22, 24, 29, 36, 39, 50, 57, 67], "version": [1, 3, 8, 11, 12, 17, 18, 20, 29, 35, 36, 37, 38, 39, 43, 57, 60, 61, 63, 64, 67, 68], "see": [1, 2, 3, 4, 5, 6, 12, 14, 18, 20, 22, 24, 32, 34, 35, 36, 37, 38, 39, 41, 43, 45, 50, 52, 53, 54, 55, 57, 59, 61, 63, 64, 65, 67, 68, 70], "addition": [1, 18, 63, 70], "overload": [1, 3, 20, 27, 28, 32, 34], "broadcast": [1, 2, 3, 11, 27], "singl": [1, 2, 3, 4, 12, 14, 15, 20, 23, 24, 25, 27, 32, 36, 37, 38, 43, 48, 49, 50, 52, 53, 55, 56, 57, 67], "across": [1, 2, 3, 6, 18, 27, 37, 38, 39, 49, 61, 63, 70], "vector": [1, 2, 3, 4, 5, 8, 14, 20, 22, 23, 24, 27, 30, 32, 34, 37, 38, 45, 46, 49, 50, 51, 52, 54, 56, 60, 61], "For": [1, 2, 3, 4, 6, 11, 12, 13, 18, 20, 22, 27, 34, 36, 37, 38, 39, 41, 42, 43, 44, 45, 49, 51, 52, 54, 55, 56, 60, 61, 63, 65, 67, 68, 70], "exampl": [1, 3, 4, 5, 6, 8, 10, 11, 12, 17, 18, 19, 20, 22, 27, 33, 34, 36, 37, 38, 39, 41, 43, 45, 46, 48, 49, 50, 52, 53, 55, 56, 59, 60, 61, 63, 64, 65, 67, 68, 70], "cudaq": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 21, 22, 23, 24, 26, 29, 30, 31, 36, 37, 38, 39, 41, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 59, 60, 61, 63, 64, 67, 68], "qvector": [1, 2, 3, 4, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 23, 24, 27, 31, 37, 38, 41, 43, 45, 46, 48, 49, 51, 52, 54, 55, 56, 57, 67, 68], "flip": [1, 2, 3, 5, 10, 13, 53, 55], "each": [1, 2, 3, 4, 6, 7, 11, 12, 13, 14, 18, 20, 22, 25, 30, 34, 36, 37, 38, 39, 43, 49, 52, 53, 54, 55, 56, 57, 61, 63, 67, 68, 70], "thi": [1, 2, 3, 4, 6, 9, 10, 11, 12, 13, 14, 16, 19, 20, 22, 23, 24, 25, 26, 27, 29, 32, 34, 36, 37, 38, 39, 41, 43, 44, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 59, 61, 63, 64, 65, 67, 68], "pauli": [1, 2, 3, 4, 7, 9, 11, 20, 28, 43, 55, 56], "matrix": [1, 2, 3, 10, 11, 14, 18, 35, 37, 53, 55, 60, 70], "It": [1, 2, 4, 6, 12, 13, 14, 17, 18, 20, 27, 32, 34, 38, 43, 53, 55, 57, 60, 63, 65, 68, 70], "i": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 22, 23, 24, 25, 26, 27, 28, 29, 32, 34, 35, 36, 37, 38, 39, 40, 43, 44, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 59, 60, 61, 63, 64, 65, 67, 68, 70], "also": [1, 2, 3, 4, 6, 10, 12, 13, 14, 15, 18, 20, 24, 28, 36, 37, 38, 39, 41, 42, 43, 49, 52, 55, 56, 57, 59, 60, 61, 63, 65, 68, 70], "known": [1, 2, 24, 50, 57], "NOT": [1, 20, 27, 55], "gate": [1, 2, 4, 5, 6, 8, 10, 11, 12, 13, 14, 18, 27, 31, 32, 34, 36, 39, 41, 45, 50, 51, 53, 56, 60, 70], "appli": [1, 2, 3, 6, 8, 10, 11, 12, 13, 20, 23, 24, 27, 31, 34, 37, 38, 41, 45, 50, 51, 53, 55, 56, 57, 60], "0": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 22, 23, 24, 27, 28, 29, 30, 32, 34, 35, 36, 37, 38, 39, 41, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 60, 61, 63, 65, 67, 68, 70], "1": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 34, 36, 37, 38, 39, 41, 43, 44, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 60, 61, 63, 67, 68, 70], "rotat": [1, 3, 4, 10, 11, 12, 13, 14, 27, 28, 41, 48, 53, 56, 60], "\u03c0": [1, 53], "about": [1, 2, 4, 6, 13, 14, 15, 18, 20, 34, 37, 38, 39, 42, 43, 49, 52, 53, 61, 63, 65, 66, 67, 68, 70], "axi": [1, 8, 15, 53], "enabl": [1, 2, 3, 4, 12, 19, 20, 22, 24, 25, 27, 29, 30, 31, 32, 35, 38, 39, 42, 43, 48, 49, 52, 57, 60, 61, 63, 67, 68], "one": [1, 2, 3, 4, 5, 6, 11, 12, 14, 18, 20, 22, 23, 25, 27, 30, 34, 36, 37, 38, 39, 44, 48, 49, 51, 52, 55, 56, 57, 59, 60, 61, 63, 67, 68, 70], "creat": [1, 2, 3, 4, 10, 11, 12, 13, 14, 15, 17, 20, 22, 28, 31, 36, 37, 38, 42, 43, 49, 50, 52, 53, 54, 56, 57, 58, 60, 61, 63, 64, 65, 67, 68], "superposit": [1, 6, 11, 14, 20, 23, 32, 38, 41, 43, 45, 53, 54, 55], "comput": [1, 2, 3, 4, 6, 8, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20, 22, 23, 24, 30, 32, 34, 37, 38, 39, 42, 43, 47, 52, 54, 56, 60, 61, 65, 67, 68], "basi": [1, 2, 3, 10, 12, 13, 16, 32, 37, 38, 53, 55, 56], "sqrt": [1, 3, 6, 7, 10, 12, 13, 23, 53, 55, 68], "2": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 34, 36, 37, 38, 39, 43, 45, 48, 49, 51, 52, 53, 54, 55, 56, 57, 61, 63, 65, 67, 68, 70], "an": [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17, 18, 20, 22, 24, 25, 27, 28, 30, 31, 32, 34, 36, 37, 38, 39, 41, 43, 45, 46, 48, 49, 51, 52, 53, 55, 56, 57, 58, 59, 60, 61, 63, 65, 68, 69, 70], "arbitrari": [1, 2, 36, 51, 67], "\u03bb": 1, "exp": [1, 2, 23, 28], "i\u03bb": 1, "math": [1, 6, 37], "pi": [1, 4, 8, 9, 11, 12, 14, 15, 23, 24, 29, 31, 36, 37, 49, 54], "std": [1, 2, 3, 20, 22, 23, 24, 27, 28, 30, 31, 32, 37, 38, 43, 45, 49, 50, 52, 54, 56, 59, 60, 65, 67], "number": [1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 20, 23, 28, 30, 32, 34, 36, 37, 38, 39, 41, 43, 45, 46, 48, 49, 50, 51, 52, 55, 56, 57, 60, 63, 68], "\u03b8": 1, "co": [1, 12], "isin": 1, "sin": [1, 12], "its": [1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 13, 18, 19, 20, 30, 32, 34, 37, 38, 39, 43, 45, 50, 54, 55, 56, 57, 60, 61, 63, 67, 68, 69, 70], "4": [1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 22, 23, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 38, 39, 49, 52, 54, 56, 57, 61, 63, 67, 70], "i\u03c0": 1, "two": [1, 2, 3, 4, 6, 7, 9, 10, 11, 13, 14, 25, 34, 36, 38, 43, 48, 49, 51, 53, 55, 63, 67], "qubit_1": [1, 6, 11], "qubit_2": 1, "univers": [1, 4, 37, 55], "three": [1, 13, 25, 36, 37, 48], "paramet": [1, 2, 3, 4, 5, 8, 9, 11, 15, 16, 20, 24, 27, 32, 36, 37, 41, 46, 48, 49, 50, 52, 54, 56, 60, 61], "euler": 1, "angl": [1, 2, 3, 5, 7, 12, 13, 14, 23, 24, 27, 38, 41, 48, 49, 56], "theta": [1, 4, 7, 8, 9, 10, 11, 12, 15, 16, 20, 22, 23, 37, 38, 48, 54, 56], "phi": [1, 7, 20, 22, 57], "\u03c6": 1, "lambda": [1, 2, 4, 9, 11, 13, 20, 23, 24, 29, 51, 52, 56, 57], "i\u03c6": 1, "np": [1, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 23, 24, 29, 31, 36, 38, 39, 49, 52, 53, 54, 61], "m_pi": [1, 23, 31, 49, 54], "m_pi_2": [1, 23, 24, 37], "adj": [1, 27], "method": [1, 2, 3, 4, 6, 8, 13, 15, 16, 20, 22, 27, 32, 38, 39, 43, 50], "ani": [1, 2, 3, 4, 10, 11, 14, 20, 24, 26, 27, 29, 31, 32, 36, 37, 39, 41, 43, 44, 49, 50, 51, 53, 60, 61, 63, 67, 68], "alloc": [1, 2, 3, 5, 11, 20, 22, 23, 24, 25, 32, 38, 39, 41, 43, 45, 50, 51, 53, 56, 60], "now": [1, 4, 6, 7, 11, 12, 14, 15, 18, 34, 43, 49, 50, 51, 52, 53, 54, 63, 68, 70], "again": [1, 20, 34, 53, 63, 65], "initi": [1, 2, 3, 4, 5, 9, 11, 12, 15, 16, 20, 36, 38, 49, 52, 53, 54, 55, 56, 61, 63], "ctrl": [1, 2, 6, 11, 14, 20, 22, 23, 27, 37, 38, 41, 45, 46, 48, 49, 50, 51, 54, 55, 56, 57, 63, 68], "condit": [1, 2, 10, 12, 20, 21, 22, 24, 25, 39, 42, 55, 57], "more": [1, 2, 3, 4, 9, 11, 12, 13, 14, 18, 22, 25, 27, 28, 34, 36, 37, 38, 39, 42, 43, 49, 52, 54, 55, 56, 61, 63, 65, 67, 68, 70], "wikipedia": 1, "entri": [1, 20, 24, 38, 49, 57, 63, 67], "ctrl_1": 1, "ctrl_2": 1, "00": [1, 4, 10, 14, 43, 52, 55, 67, 68], "11": [1, 3, 4, 10, 13, 14, 20, 37, 43, 52, 55, 57, 61, 63, 67, 68], "onli": [1, 2, 3, 4, 13, 20, 24, 25, 29, 32, 34, 36, 37, 38, 42, 45, 46, 49, 55, 57, 59, 61, 63, 67, 68], "both": [1, 3, 6, 8, 25, 34, 36, 38, 39, 55, 56, 61, 63, 65], "000": [1, 12, 13, 37, 43], "111": [1, 4, 12, 13], "follow": [1, 2, 3, 4, 6, 7, 11, 12, 13, 14, 18, 20, 22, 24, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 41, 43, 44, 48, 49, 50, 53, 57, 59, 60, 61, 63, 64, 65, 67, 68, 70], "common": [1, 4, 13, 15, 20, 24, 27, 28, 57, 61], "convent": [1, 8, 11], "all": [1, 2, 3, 4, 7, 13, 14, 17, 18, 19, 20, 21, 22, 24, 25, 26, 27, 29, 30, 32, 34, 36, 37, 38, 39, 43, 45, 48, 49, 52, 53, 54, 55, 56, 57, 61, 63, 64, 65, 67, 68, 70], "howev": [1, 4, 12, 13, 34, 36, 38, 67, 68], "behavior": [1, 2, 4], "chang": [1, 2, 4, 12, 18, 20, 24, 43, 63, 68, 70], "instead": [1, 2, 4, 10, 14, 26, 29, 38, 39, 43, 61, 63, 67], "when": [1, 2, 3, 4, 11, 13, 20, 25, 32, 34, 37, 38, 39, 43, 48, 49, 50, 53, 57, 60, 61, 63, 67, 68], "negat": [1, 2, 3, 27, 31, 32], "polar": [1, 27, 31, 39], "syntax": [1, 4, 18, 19, 24, 25, 27, 29, 36, 49, 65, 70], "preced": [1, 27, 36], "01": [1, 6, 10, 55], "10": [1, 4, 8, 9, 10, 11, 13, 14, 16, 20, 23, 24, 43, 50, 52, 55, 56, 57, 65, 68], "notat": [1, 55], "context": [1, 2, 8, 25, 38, 39, 60], "valid": [1, 2, 3, 17, 24, 36, 39, 49, 61, 63, 67], "either": [1, 6, 8, 11, 25, 36, 38, 39, 49, 55, 56, 61, 63, 68], "similarli": [1, 6, 38, 44, 55], "condition": 1, "respect": [1, 2, 3, 11, 20, 36, 38, 43, 48, 52, 61, 63, 68], "e": [1, 2, 3, 4, 6, 7, 11, 12, 13, 15, 16, 19, 20, 21, 23, 24, 25, 26, 27, 28, 34, 36, 37, 38, 39, 46, 49, 57, 60, 61, 63, 67, 68], "project": [1, 39, 60, 61, 63, 64, 67], "onto": [1, 55], "eigenvector": [1, 2, 7], "non": [1, 2, 3, 9, 13, 20, 24, 25, 32, 38, 39, 43, 48, 50], "linear": [1, 4, 8, 10, 12, 15, 37, 43, 49, 55], "avail": [1, 2, 3, 4, 9, 17, 18, 19, 20, 24, 25, 27, 30, 31, 32, 33, 35, 36, 37, 38, 39, 42, 43, 45, 47, 48, 57, 61, 63, 68, 70], "first": [1, 2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 17, 20, 32, 36, 37, 38, 39, 40, 48, 49, 50, 51, 53, 56, 57, 63, 68], "api": [1, 14, 17, 20, 22, 26, 27, 30, 32, 36, 37, 38, 39, 43, 50, 60, 61, 63, 65, 67], "regist": [1, 2, 3, 12, 15, 20, 23, 25, 32, 36, 38, 45, 50, 51, 53, 57, 60], "outsid": [1, 4, 63, 67], "Then": [1, 13, 45, 49, 53, 59, 60], "within": [1, 2, 3, 15, 20, 24, 26, 28, 32, 36, 38, 39, 42, 43, 49, 50, 53, 55, 59, 61, 63, 64, 65, 67, 68], "like": [1, 2, 3, 4, 6, 11, 12, 14, 15, 18, 20, 24, 32, 36, 38, 43, 49, 50, 52, 55, 56, 57, 61, 63, 64, 67, 68, 70], "built": [1, 2, 4, 5, 12, 18, 36, 39, 42, 43, 46, 53, 56, 61, 67, 68, 70], "abov": [1, 4, 6, 11, 12, 20, 22, 27, 37, 38, 39, 43, 48, 49, 51, 55, 57, 60, 61, 63, 65, 67, 68], "qudit": [1, 2, 21, 25, 27], "level": [1, 2, 18, 19, 20, 25, 27, 37, 38, 39, 57, 60, 64, 70], "register_oper": 1, "accept": [1, 2, 3, 41, 61, 63, 68], "identifi": [1, 2, 11, 45, 61, 63], "string": [1, 2, 3, 14, 20, 22, 23, 30, 39, 43, 50, 57, 63, 67], "numpi": [1, 3, 4, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 23, 49, 52, 53, 54, 61], "arrai": [1, 2, 3, 6, 7, 10, 12, 13, 32, 34, 38, 50, 52, 53, 57], "complex": [1, 2, 3, 9, 10, 16, 28, 34, 38, 43, 52, 53, 55, 56, 67], "A": [1, 2, 3, 4, 6, 11, 13, 14, 15, 20, 23, 24, 27, 34, 36, 43, 49, 51, 52, 55, 59, 60, 61, 63], "1d": [1, 2, 3, 14], "interpret": [1, 42, 61], "row": [1, 2, 3, 14], "major": [1, 61], "import": [1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 23, 28, 36, 37, 38, 39, 41, 43, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 57, 61, 67, 68], "custom_h": 1, "custom_x": 1, "def": [1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 23, 24, 29, 31, 37, 38, 41, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 63, 68], "bell": [1, 20, 67], "sampl": [1, 2, 3, 4, 6, 9, 10, 11, 13, 22, 36, 37, 38, 39, 40, 42, 45, 46, 49, 50, 51, 52, 53, 54, 55, 60, 63, 67, 68], "dump": [1, 2, 3, 10, 20, 23, 37, 38, 43, 45, 46, 49, 50, 52, 53, 54, 67, 68], "macro": [1, 60], "cudaq_register_oper": 1, "uniqu": [1, 2, 3, 4, 11, 13, 20, 25, 27, 32, 38, 65], "name": [1, 2, 3, 4, 11, 20, 22, 27, 30, 35, 37, 38, 39, 48, 52, 55, 57, 60, 61, 63, 64, 67, 68], "represent": [1, 2, 3, 12, 14, 20, 24, 34, 39, 57, 59, 60], "includ": [1, 2, 3, 11, 18, 20, 23, 32, 37, 41, 42, 43, 45, 46, 48, 49, 50, 51, 53, 54, 56, 57, 59, 60, 61, 63, 65, 67, 68, 70], "m_sqrt1_2": 1, "__qpu__": [1, 2, 20, 23, 24, 31, 37, 38, 41, 43, 45, 46, 48, 49, 50, 51, 53, 54, 56, 57, 67, 68], "void": [1, 2, 3, 20, 22, 23, 24, 27, 28, 30, 31, 32, 41, 43, 45, 49, 51, 54, 56, 57, 59, 60, 65, 67, 68], "bell_pair": [1, 2, 3], "r": [1, 13, 27, 32, 36, 37, 38, 39, 48, 49, 56, 57, 63], "int": [1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 16, 20, 23, 24, 31, 32, 37, 38, 41, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 56, 57, 60, 61, 65, 67, 68], "main": [1, 4, 18, 20, 23, 34, 37, 43, 45, 46, 48, 49, 50, 51, 53, 54, 56, 57, 61, 63, 65, 67, 68, 70], "auto": [1, 2, 20, 22, 23, 24, 28, 31, 32, 37, 38, 39, 41, 43, 45, 46, 48, 49, 50, 51, 53, 54, 56, 57, 59, 67, 68], "count": [1, 2, 3, 4, 7, 9, 11, 13, 20, 22, 23, 32, 36, 37, 38, 39, 43, 46, 49, 50, 51, 52, 53, 54, 56, 57, 60], "bit": [1, 2, 6, 10, 13, 20, 23, 25, 32, 34, 38, 39, 45, 46, 50, 51, 53, 55, 60], "printf": [1, 20, 23, 32, 38, 46, 48, 50, 51, 54, 56, 61], "n": [1, 2, 4, 7, 11, 12, 13, 16, 20, 22, 23, 24, 27, 28, 31, 37, 38, 43, 45, 46, 48, 49, 50, 51, 52, 54, 55, 56, 57, 61, 65, 68], "data": [1, 2, 8, 9, 11, 12, 15, 17, 20, 24, 26, 28, 34, 38, 39, 46, 48, 50, 51, 57, 60, 62, 63, 65, 67], "multi": [1, 12, 14, 17, 18, 19, 22, 25, 27, 31, 35, 36, 37, 43, 47, 48, 55, 60, 61, 67, 68, 70], "msb": 1, "order": [1, 2, 4, 11, 20, 28, 36, 39, 43, 48, 53], "big": [1, 9], "endian": 1, "show": [1, 4, 8, 9, 11, 12, 13, 14, 15, 16, 38, 48, 49, 53, 61, 63], "differ": [1, 2, 3, 4, 6, 7, 8, 12, 13, 14, 34, 36, 37, 38, 42, 43, 49, 52, 53, 61, 63, 65], "test": [1, 4, 8, 13, 17, 22, 52, 61, 63], "cnot": [1, 4, 27, 41, 55, 67], "my_cnot": 1, "print": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 23, 32, 37, 38, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 61, 67, 68], "500": [1, 55, 68], "exact": [1, 4, 39], "random": [1, 2, 3, 4, 9, 11, 13, 14, 15, 16, 38, 39, 45, 52, 54, 56], "construct": [1, 2, 4, 13, 14, 20, 21, 22, 24, 32, 34, 38, 41, 42, 43, 50, 53, 57], "second": [1, 2, 3, 4, 6, 11, 13, 32, 37, 39, 43, 56], "1j": 1, "xy": 1, "kron": [1, 13], "my_xi": 1, "custom_xy_test": 1, "undo": 1, "prior": [1, 55, 61, 63], "1000": [1, 3, 4, 8, 10, 13, 20, 36, 43, 50, 52, 55, 68], "mycnot": 1, "myxi": 1, "current": [1, 2, 3, 4, 14, 18, 20, 30, 36, 38, 39, 45, 60, 63, 67, 70], "simul": [1, 2, 5, 9, 13, 14, 17, 18, 19, 20, 35, 36, 40, 42, 43, 45, 47, 49, 50, 52, 57, 58, 61, 68, 70], "attempt": [1, 2, 67], "hardwar": [1, 4, 12, 17, 18, 35, 39, 43, 47, 67, 70], "result": [1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 13, 14, 15, 16, 20, 21, 22, 23, 25, 34, 36, 37, 38, 39, 43, 45, 46, 48, 49, 50, 51, 52, 53, 55, 57, 60, 63, 67, 68], "runtim": [1, 2, 4, 9, 19, 20, 22, 25, 36, 37, 38, 39, 46, 48, 57, 60, 63, 65], "error": [1, 2, 4, 7, 10, 14, 17, 27, 34, 36, 37, 39, 42, 49, 53, 61, 63, 67], "class": [2, 3, 4, 8, 20, 22, 24, 28, 30, 32, 38, 39, 56, 59, 60], "spin_op": [2, 3, 20, 23, 27, 37, 38, 43, 48, 54, 56], "repres": [2, 3, 4, 6, 10, 11, 12, 14, 20, 34, 36, 39, 49, 55, 56, 57], "gener": [2, 3, 4, 7, 9, 11, 12, 13, 14, 15, 20, 22, 23, 24, 25, 27, 28, 31, 33, 36, 37, 42, 45, 46, 48, 49, 50, 51, 55, 57, 59, 63, 67], "sum": [2, 3, 8, 11, 13, 28, 32, 49, 55], "tensor": [2, 3, 8, 13, 18, 28, 37, 38, 46, 60, 70], "product": [2, 3, 13, 17, 18, 28, 37, 45, 68, 70], "expos": [2, 3, 4, 20, 22, 28, 30, 34, 38, 60], "typic": [2, 20, 32, 37, 41, 42, 48, 57, 64, 65], "algebra": [2, 28, 48, 55], "programm": [2, 3, 20, 21, 22, 24, 25, 27, 29, 30, 32, 36, 38, 50], "defin": [2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 19, 20, 21, 22, 23, 24, 28, 29, 30, 31, 32, 37, 38, 39, 41, 42, 43, 45, 46, 48, 49, 50, 51, 53, 54, 55, 56, 57, 60, 61, 63, 65, 67], "primit": [2, 11, 19, 22, 25, 28, 32, 33, 38, 42, 67], "them": [2, 4, 7, 9, 13, 14, 18, 34, 41, 55, 57, 61, 63, 65, 67, 68, 70], "compos": [2, 3, 8, 11, 24, 25, 36, 49, 57], "larger": [2, 3, 4, 11, 37, 45, 46], "thereof": [2, 25, 28], "public": [2, 4, 20, 22, 28, 30, 32, 38, 45, 56, 59, 60, 63], "type": [2, 4, 5, 6, 11, 12, 13, 19, 20, 22, 24, 25, 27, 28, 33, 36, 38, 39, 41, 45, 48, 50, 53, 54, 55, 56, 57, 60, 63, 67], "spin_op_term": 2, "bool": [2, 3, 20, 24, 27, 28, 30, 38, 60, 67], "we": [2, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 18, 20, 23, 27, 29, 34, 36, 38, 39, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 59, 60, 61, 63, 64, 65, 67, 68, 70], "term": [2, 3, 9, 11, 16, 20, 27, 36, 38, 43, 48, 63], "binari": [2, 3, 4, 8, 11, 12, 18, 36, 45, 61, 65, 70], "symplect": 2, "form": [2, 3, 4, 18, 20, 27, 32, 34, 39, 57, 70], "size": [2, 3, 4, 8, 13, 20, 22, 23, 24, 25, 32, 37, 38, 39, 45, 46, 49, 50, 52, 63, 67], "nqubit": [2, 22, 23, 56, 60], "where": [2, 3, 4, 6, 7, 8, 11, 12, 13, 19, 25, 27, 28, 32, 34, 36, 39, 43, 49, 52, 53, 55, 60, 61, 63, 65], "element": [2, 3, 12, 13, 20, 32, 38, 55], "x": [2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 22, 23, 24, 27, 28, 29, 31, 36, 37, 38, 39, 41, 43, 45, 46, 48, 49, 50, 51, 53, 54, 55, 56, 57, 61, 63, 65, 68], "next": [2, 4, 14, 34, 49, 50, 56, 57, 61], "z": [2, 3, 4, 5, 8, 9, 10, 11, 14, 15, 20, 23, 27, 28, 37, 38, 43, 45, 48, 50, 52, 53, 54, 56, 61], "y": [2, 3, 4, 6, 8, 12, 13, 14, 16, 20, 23, 27, 28, 37, 38, 43, 48, 50, 53, 56, 61, 63, 65, 68], "site": [2, 68], "csr_spmatrix": 2, "tupl": [2, 3, 4, 20, 24, 56], "doubl": [2, 3, 15, 20, 22, 23, 24, 27, 28, 31, 37, 38, 39, 43, 48, 49, 54, 56, 60, 61, 63], "size_t": [2, 20, 22, 24, 28, 30, 32, 38, 49, 50, 60, 65, 67], "typedef": 2, "zero": [2, 3, 5, 7, 8, 13, 25, 38, 43, 55], "spars": [2, 3], "function": [2, 3, 5, 6, 8, 9, 10, 11, 13, 14, 15, 16, 18, 22, 23, 24, 26, 27, 28, 29, 30, 31, 32, 36, 37, 38, 39, 41, 42, 43, 45, 48, 49, 50, 52, 53, 54, 56, 57, 60, 65, 67, 70], "pair": [2, 3, 11, 24, 30, 34, 63], "const": [2, 20, 22, 23, 24, 27, 28, 30, 32, 37, 46, 49, 54, 56, 59, 60, 65, 67], "termdata": 2, "constructor": [2, 3], "take": [2, 3, 4, 6, 11, 12, 13, 18, 20, 22, 23, 24, 27, 28, 29, 30, 31, 32, 34, 36, 39, 42, 43, 46, 48, 49, 50, 51, 52, 53, 56, 57, 61, 63, 68, 70], "coeffici": [2, 3, 9, 55], "constant": [2, 6, 32, 34, 57], "id": [2, 20, 30, 32, 36, 38, 61, 63], "coeff": 2, "qubit": [2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 15, 16, 20, 22, 23, 24, 25, 28, 30, 31, 34, 36, 37, 38, 39, 41, 42, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 60, 63, 68], "unordered_map": [2, 20], "_term": 2, "full": [2, 3, 18, 37, 38, 52, 55, 57, 59, 61, 63, 64, 70], "composit": 2, "spin": [2, 3, 4, 5, 7, 8, 9, 10, 11, 16, 20, 23, 28, 34, 37, 38, 43, 48, 52, 54, 56, 57], "op": [2, 3, 34, 48, 56, 57], "map": [2, 3, 4, 10, 13, 20, 32, 57, 63], "individu": [2, 3, 25, 32, 38], "bsf": 2, "from": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 18, 20, 21, 23, 24, 25, 28, 32, 34, 37, 38, 39, 42, 43, 45, 48, 49, 52, 53, 54, 56, 57, 60, 63, 64, 65, 68, 70], "ident": [2, 3, 11, 13, 34, 48], "numqubit": [2, 3, 23], "given": [2, 3, 4, 6, 9, 11, 13, 20, 32, 36, 38, 39, 43, 45, 48, 56, 60], "o": [2, 4, 7, 12, 16, 23, 36, 37, 38, 39, 46, 48, 49, 50, 51, 53, 56, 57, 61, 63, 65, 67, 68], "copi": [2, 14, 32, 34, 61, 63], "data_rep": 2, "serial": [2, 3], "encod": [2, 3, 4, 11, 20, 28, 38, 45, 50, 55, 60], "via": [2, 3, 6, 8, 10, 17, 19, 20, 22, 25, 27, 29, 31, 32, 34, 36, 38, 39, 46, 48, 49, 50, 51, 52, 53, 55, 57, 59, 60, 61], "3": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 21, 22, 23, 24, 25, 27, 28, 29, 30, 31, 32, 36, 37, 38, 39, 43, 49, 51, 52, 53, 54, 56, 57, 60, 61, 63, 64, 68, 70], "real": [2, 3, 7, 9, 12, 16, 42], "imaginari": [2, 3, 16], "part": [2, 3, 16, 20, 32, 57, 59, 61, 63], "append": [2, 3, 5, 7, 8, 9, 13, 14, 15, 16, 24, 36, 38, 45, 52], "larg": [2, 3, 13, 27, 38, 39, 42, 46, 55], "end": [2, 3, 6, 10, 12, 13, 14, 20, 32, 36, 38, 43, 49, 53, 55, 61, 63], "total": [2, 3, 4, 8, 9, 12, 16, 37, 38, 39, 43, 49, 52, 63], "destructor": 2, "iter": [2, 3, 4, 20, 32, 49, 56], "begin": [2, 3, 4, 6, 10, 12, 13, 14, 15, 20, 32, 41, 49, 50, 53, 55, 56], "return": [2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15, 16, 20, 22, 23, 24, 27, 32, 34, 37, 38, 43, 45, 46, 48, 49, 50, 52, 53, 54, 56, 57, 59, 60, 61, 65, 67], "start": [2, 3, 5, 12, 17, 18, 27, 32, 36, 38, 43, 57, 59, 65, 70], "equal": [2, 3, 14, 34, 38, 39, 43, 55], "v": [2, 3, 7, 9, 11, 17, 20, 23, 24, 29, 34, 37, 52, 57, 61], "noexcept": [2, 27], "add": [2, 3, 4, 10, 11, 14, 15, 18, 29, 39, 49, 50, 53, 57, 59, 60, 61, 63, 70], "subtract": [2, 3], "multipli": [2, 3], "true": [2, 3, 4, 8, 13, 20, 24, 36, 52, 61, 63, 68], "here": [2, 3, 4, 6, 10, 12, 13, 15, 17, 18, 20, 22, 23, 24, 27, 29, 37, 38, 45, 46, 48, 50, 51, 53, 54, 56, 57, 59, 61, 63, 67, 68, 70], "doe": [2, 3, 4, 6, 12, 14, 18, 20, 24, 32, 37, 38, 61, 63, 65, 67, 68, 70], "consid": [2, 3, 4, 6, 7, 13, 23, 25, 34, 37, 38, 57, 63], "valu": [2, 3, 4, 5, 6, 8, 9, 11, 13, 16, 17, 20, 22, 24, 28, 32, 34, 37, 38, 39, 43, 45, 47, 52, 54, 55, 56, 57, 61, 67, 68], "num_qubit": [2, 3, 28, 37, 56], "num_term": [2, 28], "get_coeffici": [2, 3, 9, 28], "get": [2, 3, 7, 10, 12, 13, 14, 18, 20, 22, 23, 32, 36, 37, 38, 43, 48, 49, 52, 60, 61, 65, 68, 70], "throw": [2, 14], "except": [2, 3, 4, 14, 67], "get_raw_data": [2, 3], "is_ident": [2, 3, 28], "standard": [2, 3, 19, 20, 21, 22, 24, 27, 33, 38, 41, 42, 46, 57, 59, 61, 63, 65, 67], "out": [2, 3, 4, 6, 8, 10, 11, 12, 14, 18, 20, 25, 32, 34, 38, 39, 43, 44, 48, 49, 53, 56, 60, 63, 64, 67, 70], "to_str": [2, 3, 9, 43], "printcoeffici": 2, "getdatarepresent": 2, "getdatatupl": 2, "fulli": [2, 3, 4, 8, 18, 19, 38, 50, 57, 61, 63, 67, 70], "distribute_term": [2, 3], "numchunk": 2, "distribut": [2, 3, 10, 13, 18, 25, 37, 39, 43, 48, 50, 61, 67, 70], "chunk": [2, 3, 25], "for_each_term": [2, 3, 9, 28], "give": [2, 7, 11, 12, 13, 18, 20, 38, 39, 53, 61, 63, 69, 70], "functor": 2, "reduct": 2, "captur": [2, 11, 18, 24, 70], "variabl": [2, 4, 11, 18, 24, 25, 36, 37, 38, 44, 46, 49, 52, 53, 61, 63, 68, 70], "for_each_pauli": [2, 3, 28], "thrown": [2, 3, 67], "than": [2, 3, 11, 12, 14, 27, 34, 37, 39, 43, 55, 61, 63, 67], "user": [2, 3, 4, 13, 14, 18, 20, 22, 23, 25, 26, 29, 32, 36, 37, 38, 39, 49, 52, 53, 57, 60, 61, 63, 70], "should": [2, 3, 12, 19, 20, 25, 27, 28, 30, 32, 36, 38, 39, 43, 45, 53, 60, 61, 63, 67, 68], "pass": [2, 3, 4, 8, 9, 14, 17, 20, 24, 25, 28, 32, 36, 38, 46, 49, 51, 53, 56, 57, 58, 63, 67], "index": [2, 3, 4, 28, 30, 32, 34, 38, 45, 60], "complex_matrix": 2, "to_matrix": [2, 3, 7], "dens": 2, "to_sparse_matrix": [2, 3], "col": 2, "static": [2, 3, 20, 27, 32, 57, 61, 67], "nterm": 2, "unsign": 2, "seed": [2, 3, 9, 11, 13, 14, 15, 16, 39, 52, 54], "random_devic": 2, "act": [2, 4, 5, 6, 11, 34, 55], "specifi": [2, 3, 4, 8, 9, 11, 12, 13, 14, 20, 23, 24, 25, 27, 28, 29, 30, 32, 36, 37, 38, 39, 43, 45, 49, 50, 52, 53, 54, 57, 60, 61, 63], "overrid": [2, 20, 39, 59, 61], "repeat": [2, 13, 20, 54, 56], "from_word": [2, 3], "pauliword": 2, "input": [2, 3, 4, 6, 8, 9, 12, 20, 22, 23, 24, 31, 32, 38, 43, 48, 49, 52, 56], "word": [2, 3, 9, 53], "g": [2, 3, 4, 11, 19, 20, 21, 24, 25, 26, 27, 28, 34, 36, 37, 38, 39, 49, 57, 60, 61, 63, 64, 67, 68], "xyx": [2, 3], "3rd": 2, "typenam": [2, 20, 22, 23, 24, 27, 31, 32, 49, 65, 67], "qualifiedspinop": 2, "struct": [2, 20, 22, 23, 24, 27, 31, 37, 38, 46, 48, 49, 50, 51, 54, 56, 57, 59, 67], "constexpr": [2, 22, 32, 37], "dyn": [2, 32, 46, 53], "d": [2, 3, 4, 23, 24, 25, 32, 36, 49, 53, 56, 63], "system": [2, 3, 4, 14, 15, 20, 25, 30, 32, 34, 38, 39, 42, 43, 48, 49, 52, 53, 55, 56, 59, 61, 64, 65, 67, 68], "inlin": [2, 20, 57], "new": [2, 3, 4, 12, 14, 17, 18, 20, 22, 34, 42, 57, 58, 61, 63, 67, 68, 70], "enable_if_t": 2, "qreg": [2, 3, 11, 37], "contain": [2, 3, 4, 11, 13, 17, 18, 20, 25, 27, 30, 34, 37, 39, 42, 43, 48, 49, 54, 56, 57, 60, 61, 67, 68, 70], "dynam": [2, 3, 22, 24, 25, 32, 41, 42, 46, 57, 67], "time": [2, 3, 4, 10, 11, 12, 13, 14, 16, 19, 20, 23, 25, 32, 33, 36, 37, 38, 39, 43, 46, 49, 50, 52, 55, 57, 61, 63, 68], "By": [2, 4, 20, 27, 36, 37, 38, 39, 43, 49, 65], "value_typ": 2, "indic": [2, 3, 24, 27, 28, 32, 53, 60], "underli": [2, 3, 4, 20, 30, 32, 36, 38, 60], "interfac": [2, 32, 39, 60, 61, 63, 65], "idx": [2, 3, 8, 32, 38], "qspan": 2, "front": [2, 23, 31, 32, 51], "back": [2, 23, 32, 34, 38, 49, 50, 53, 63], "last": [2, 13, 23, 32, 38, 48, 56], "slice": [2, 3, 32, 56], "clear": [2, 3, 20, 32, 60], "destroi": [2, 32], "postcondit": [2, 32], "own": [2, 3, 4, 10, 13, 25, 30, 32, 39, 56, 57, 60, 61, 63, 67], "semant": [2, 3, 19, 24, 25, 26, 29, 31, 32, 34, 57], "held": 2, "explicit": [2, 20, 31, 39, 49, 67], "determin": [2, 4, 6, 43], "If": [2, 3, 4, 6, 8, 9, 12, 13, 14, 20, 34, 37, 39, 43, 45, 49, 52, 55, 56, 61, 63, 67, 68], "check": [2, 4, 18, 36, 37, 49, 55, 61, 63, 70], "norm": [2, 13], "pre": [2, 16, 18, 20, 36, 39, 48, 49, 51, 61, 67, 70], "exist": [2, 3, 14, 18, 19, 20, 25, 26, 43, 59, 61, 63, 67, 68, 70], "could": [2, 4, 37, 41, 55, 56, 61], "from_data": [2, 3], "retriev": [2, 3, 20, 38, 49], "get_stat": [2, 3, 7, 12, 14, 38], "delet": [2, 32, 63, 67], "cannot": [2, 12, 14, 23, 24, 32, 34, 55, 63], "move": [2, 8, 32, 59, 61, 63, 68], "assign": [2, 4, 11, 30, 38, 39, 61], "qview": [2, 7, 12, 23, 24, 31, 45], "observe_result": [2, 3, 20, 48], "encapsul": [2, 8, 20, 32, 38, 67], "observ": [2, 3, 4, 5, 7, 8, 9, 10, 11, 13, 15, 16, 23, 36, 38, 39, 40, 42, 46, 48, 50, 51, 52, 54, 55, 56, 60, 68], "call": [2, 3, 4, 5, 6, 8, 10, 11, 12, 14, 15, 22, 23, 24, 27, 31, 38, 39, 42, 43, 49, 50, 51, 52, 54, 55, 56, 57, 60, 61, 63, 65], "measur": [2, 3, 4, 6, 7, 8, 10, 12, 13, 20, 21, 23, 24, 25, 27, 34, 36, 38, 39, 41, 42, 43, 45, 49, 50, 53, 56, 57, 60, 68], "execut": [2, 4, 12, 14, 18, 19, 20, 22, 24, 25, 30, 31, 36, 38, 39, 42, 43, 44, 45, 46, 48, 49, 50, 52, 57, 60, 63, 64, 65, 67, 68, 70], "ansatz": [2, 4, 5, 11, 15, 16, 20, 23, 37, 38, 48, 54, 56], "circuit": [2, 3, 4, 6, 7, 8, 11, 12, 13, 19, 20, 24, 25, 28, 29, 33, 34, 36, 37, 38, 39, 42, 43, 48, 49, 54, 56, 57, 59], "global": [2, 3, 4, 11, 20, 24, 37, 43, 61], "expect": [2, 3, 4, 5, 8, 9, 10, 11, 13, 15, 16, 17, 20, 37, 38, 39, 43, 47, 52, 53, 54, 56, 61, 63, 67, 68], "h": [2, 3, 4, 6, 7, 9, 11, 12, 13, 14, 15, 16, 20, 22, 23, 27, 28, 29, 31, 32, 34, 36, 37, 38, 41, 43, 45, 46, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 59, 60, 61, 63, 65, 67, 68], "precomput": 2, "psi": [2, 5, 6, 7, 20, 23, 43, 55], "sample_result": [2, 3, 20, 49, 67], "wa": [2, 3, 4, 6, 20, 38, 50, 57, 61, 64, 68], "shot": [2, 3, 4, 7, 9, 13, 20, 23, 36, 43, 50, 55, 60], "base": [2, 3, 4, 8, 12, 13, 18, 19, 20, 22, 26, 27, 32, 37, 38, 39, 43, 45, 52, 56, 57, 60, 61, 63, 65, 70], "raw_data": [2, 4, 20], "raw": [2, 3, 4], "convers": [2, 20], "simpli": [2, 14, 55, 63, 68], "ignor": [2, 4, 39], "fine": [2, 20, 46, 50, 51, 55], "grain": [2, 20, 46, 50, 51], "explicitli": [2, 4, 34, 36, 39, 57, 65, 67], "request": [2, 20, 37, 38, 39, 49, 63], "oppos": [2, 67], "observe_data": 2, "spinoptyp": [2, 20], "sub": [2, 3, 19, 20, 23, 24, 32, 33, 63], "id_coeffici": [2, 20], "executioncontext": 2, "abstract": [2, 19, 20, 22, 27, 28, 30, 32, 38, 42], "how": [2, 4, 5, 11, 12, 13, 14, 15, 18, 20, 22, 27, 37, 38, 39, 42, 43, 47, 49, 50, 51, 52, 53, 54, 56, 57, 60, 61, 63, 64, 67, 68, 70], "shots_": 2, "member": [2, 3, 11, 24, 56], "basic": [2, 5, 17, 37, 63, 68], "option": [2, 3, 4, 6, 13, 15, 16, 20, 22, 27, 30, 36, 37, 38, 43, 48, 49, 51, 52, 56, 60, 61, 63], "invoc": [2, 3, 22, 24, 30, 32, 38, 39, 60], "expectationvalu": 2, "nullopt": 2, "optimization_result": [2, 20], "optresult": 2, "optim": [2, 4, 5, 8, 9, 11, 13, 16, 17, 18, 19, 29, 32, 34, 37, 39, 47, 56, 57, 59, 61, 63, 70], "hasconditionalsonmeasureresult": 2, "fals": [2, 3, 4, 9, 61, 63], "being": [2, 3, 5, 10, 19, 20, 34, 39, 49, 53, 67], "ha": [2, 3, 4, 6, 10, 11, 13, 20, 27, 34, 36, 37, 39, 42, 43, 45, 49, 52, 53, 55, 56, 61, 63, 67], "statement": [2, 6, 20, 21, 42], "noise_model": [2, 3, 10, 13, 53], "noisemodel": [2, 3, 10, 13, 53], "nullptr": 2, "canhandleobserv": 2, "flag": [2, 24, 36, 38, 39, 46, 49, 57, 59, 63, 67], "handl": [2, 3, 4, 36, 37, 38, 39, 45, 46, 49, 60, 63, 67], "task": [2, 4, 14, 20, 28, 38, 39, 43, 57, 60], "under": [2, 13, 36, 59, 60, 61, 63, 67], "asyncexec": 2, "occur": [2, 3, 4, 13, 20, 25, 49, 53, 55, 63], "asynchron": [2, 3, 20, 30, 38, 43, 49, 52], "detail": [2, 11, 18, 19, 25, 36, 37, 60, 61, 63, 68, 70], "futur": [2, 3, 20, 35, 36, 38, 39, 49, 53, 61, 63], "futureresult": 2, "store": [2, 3, 25, 32, 38, 43, 49, 52, 55, 57], "unique_ptr": 2, "simulationst": 2, "pointer": [2, 3, 67], "amplitudemap": 2, "amplitud": [2, 3, 12, 38, 52, 53, 55], "overlapcomputest": 2, "overlap": [2, 3, 38], "overlapresult": 2, "trace": [2, 3, 10, 37], "kerneltrac": 2, "run": [2, 3, 4, 6, 8, 13, 14, 16, 17, 19, 20, 23, 36, 37, 38, 39, 40, 42, 46, 48, 49, 50, 51, 52, 53, 56, 57, 60, 61, 63, 64, 67, 68], "tracer": 2, "persist": [2, 20, 25, 37, 63], "resourc": [2, 30, 37, 38, 39, 43, 56, 61, 63], "kernelnam": [2, 3], "batchiter": 2, "batch": [2, 25], "observe_n": 2, "sample_n": 2, "totaliter": 2, "registernam": [2, 20], "mid": [2, 3, 39], "mode": [2, 3, 4, 25, 36, 49, 57, 61], "keep": [2, 13, 20, 39, 56], "track": [2, 20, 55, 56], "reorderidx": 2, "inform": [2, 3, 4, 6, 18, 20, 25, 27, 30, 32, 36, 37, 38, 39, 43, 49, 52, 55, 57, 61, 63, 65, 66, 68, 70], "reorder": 2, "after": [2, 3, 4, 6, 14, 20, 43, 49, 53, 57, 61, 63], "empti": [2, 3, 22, 28, 39, 49, 53, 63], "mean": [2, 12, 27, 34, 39, 49, 52, 63, 68], "char": [2, 23, 38, 43, 61, 67, 68], "invocationresultbuff": 2, "buffer": [2, 38, 67], "note": [2, 3, 4, 11, 13, 14, 23, 25, 34, 37, 38, 43, 45, 49, 53, 55, 56, 57, 61, 63, 67], "need": [2, 4, 10, 11, 12, 13, 14, 34, 36, 37, 38, 39, 43, 48, 49, 52, 56, 60, 61, 63, 64, 67], "abl": [2, 4, 14, 20, 36, 37, 38, 43, 45, 63, 67, 68], "job": [2, 11, 20, 37, 38, 49, 63], "qpu": [2, 3, 7, 17, 18, 19, 20, 25, 30, 36, 38, 39, 42, 43, 48, 49, 52, 60, 67, 68, 70], "extra": [2, 27, 34, 36, 45, 53, 56], "configur": [2, 4, 15, 30, 36, 37, 38, 39, 49, 52, 57, 60, 61, 63, 64, 67, 68], "later": [2, 4, 6, 20, 24, 38, 49, 61, 63], "server": [2, 36, 38, 49, 63], "file": [2, 4, 20, 27, 36, 37, 38, 43, 44, 49, 52, 56, 57, 59, 60, 61, 63, 64, 65, 67, 68], "read": [2, 3, 11, 49, 56], "wrap": [2, 20, 22, 34], "t": [2, 3, 6, 7, 12, 14, 18, 20, 23, 24, 27, 28, 37, 39, 49, 50, 55, 61, 63, 70], "case": [2, 3, 4, 6, 10, 11, 12, 13, 20, 34, 41, 48, 53, 61, 65, 67], "must": [2, 3, 13, 19, 20, 24, 26, 29, 32, 34, 36, 39, 49, 53, 55, 56, 59, 60, 61, 63, 67, 68], "some": [2, 4, 8, 12, 18, 20, 34, 37, 38, 39, 55, 57, 59, 60, 61, 63, 64, 67, 68, 70], "point": [2, 3, 4, 12, 20, 24, 27, 38, 39, 57, 60, 61, 63], "same": [2, 3, 4, 6, 11, 12, 13, 14, 20, 34, 36, 38, 43, 49, 51, 52, 53, 57, 60, 61, 63, 67], "_job": 2, "qpunamein": 2, "config": [2, 60, 61, 63, 68], "info": [2, 37, 44, 57], "requir": [2, 3, 4, 6, 8, 12, 14, 20, 24, 26, 27, 29, 31, 32, 34, 36, 37, 38, 39, 45, 49, 52, 55, 61, 64, 68], "date": 2, "even": [2, 4, 6, 11, 18, 39, 56, 61, 63, 67, 70], "async_result": [2, 49], "face": [2, 26], "which": [2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 18, 20, 22, 25, 28, 32, 34, 36, 38, 39, 48, 49, 50, 52, 55, 56, 57, 60, 61, 63, 64, 67, 70], "itself": [2, 31, 34, 38, 61, 63], "collect": [2, 3, 9, 14, 43], "pertin": [2, 20, 26, 31, 32], "remot": [2, 3, 20, 25, 35, 37, 44, 52], "rest": [2, 3, 19, 36, 38, 45, 49, 61, 63, 67], "wait": [2, 3, 4, 37, 38, 43, 49], "until": [2, 3, 4, 43, 49], "readi": [2, 15, 49, 53, 63], "executionresult": 2, "correspond": [2, 3, 4, 5, 11, 20, 36, 45, 49, 50, 54, 61, 63, 65], "well": [2, 3, 13, 18, 20, 23, 25, 39, 45, 60, 63, 64, 67, 70], "integ": [2, 3, 11, 24, 30, 38, 39, 43, 52], "1st": [2, 10], "bitstr": [2, 3, 4, 11, 20, 45], "m": [2, 4, 7, 13, 14, 16, 23, 28, 38, 39, 52, 57, 61, 63, 67, 68], "tripl": [2, 57], "long": [2, 20, 23, 43, 46, 61, 63, 67, 68], "length": [2, 13, 45, 49, 56], "deseri": 2, "discuss": [2, 4, 59], "brief": [2, 53, 60], "countsdictionari": [2, 20], "assum": [2, 3, 4, 11, 13, 25, 27, 32, 38, 39, 43, 49, 60, 61, 63, 65], "expval": [2, 20], "other": [2, 3, 4, 11, 12, 13, 15, 17, 19, 22, 24, 27, 32, 34, 36, 37, 38, 39, 41, 42, 43, 49, 53, 61, 63, 67, 68], "appendresult": 2, "globalregisternam": [2, 20], "classic": [2, 4, 6, 8, 11, 12, 15, 19, 21, 24, 25, 27, 28, 32, 34, 38, 42, 43, 49, 55, 56, 57, 60, 61, 64, 67], "sequentialdata": 2, "sequenti": [2, 3, 20, 37, 43], "collat": [2, 3], "": [2, 3, 4, 7, 10, 11, 12, 13, 14, 16, 17, 20, 27, 30, 34, 36, 37, 38, 41, 42, 43, 46, 48, 49, 50, 51, 52, 53, 54, 56, 57, 59, 61, 63, 64, 65, 68], "holist": 2, "nullari": 2, "precomputedexp": 2, "__global__": [2, 3, 20, 37, 65], "has_expect": 2, "string_view": [2, 20, 60], "anoth": [2, 4, 23, 24, 34, 39, 45, 49, 51, 53, 61], "register_nam": [2, 3, 20], "tandem": [2, 52], "to_map": [2, 20], "regnam": 2, "merg": [2, 57], "necessari": [2, 36, 38, 39, 49, 53, 57, 61, 63, 67], "document": [2, 3, 14, 17, 18, 19, 27, 35, 36, 37, 59, 60, 61, 63, 67, 70], "exp_val_z": 2, "deprec": [2, 3, 16, 35, 38, 39], "probabl": [2, 3, 7, 10, 13, 20, 43, 45, 53, 55, 67], "most_prob": [2, 3, 9, 23, 43, 45, 55], "most": [2, 3, 4, 11, 18, 20, 34, 37, 43, 45, 49, 57, 61, 63, 64, 67, 70], "ostream": [2, 67], "output": [2, 3, 6, 8, 14, 24, 36, 40, 43, 57, 63, 67, 68], "stream": [2, 4, 25], "extract": [2, 3, 4, 6, 20, 22, 23, 32, 34, 43, 56, 57, 61, 63], "unord": 2, "get_margin": [2, 20], "marginalindic": [2, 20], "margin": [2, 13], "those": [2, 18, 20, 24, 34, 38, 39, 57, 70], "subset": [2, 3, 4, 8, 20, 24, 32, 34], "rvalu": 2, "refer": [2, 11, 17, 20, 24, 25, 32, 34, 36, 37, 38, 49, 54, 61, 63], "newbitstr": 2, "oldbitstr": 2, "process": [2, 3, 4, 12, 16, 19, 20, 25, 30, 36, 37, 38, 39, 42, 49, 52, 55, 57, 61, 67], "rang": [2, 4, 5, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 23, 24, 31, 32, 37, 38, 41, 45, 46, 52, 54, 63, 68, 70], "const_iter": 2, "cbegin": 2, "cend": 2, "has_even_par": 2, "pariti": 2, "extens": [2, 14, 19, 20, 26, 32, 35, 60, 63, 65, 68], "concret": [2, 3, 11, 20, 43, 48], "describ": [2, 3, 10, 13, 30, 32, 36, 51, 55, 60, 61, 63, 67], "effici": [2, 4, 39], "manner": [2, 20, 38, 60], "client": [2, 20, 37, 61], "remain": [2, 3, 31, 49, 53, 61], "gpu": [2, 3, 4, 5, 6, 8, 9, 12, 17, 18, 19, 25, 38, 40, 42, 45, 46, 47, 60, 61, 65, 67, 68, 70], "devic": [2, 3, 4, 8, 10, 13, 20, 23, 24, 27, 31, 36, 37, 38, 39, 43, 49, 56, 57, 60, 63], "cpu": [2, 4, 8, 9, 10, 11, 12, 13, 14, 17, 35, 37, 38, 42, 43, 45, 46, 52, 53, 57, 61, 63, 67, 68], "memori": [2, 4, 8, 21, 24, 25, 32, 34, 37, 38, 39, 42, 45, 52, 57, 63], "primari": [2, 3, 20, 32, 60], "goal": [2, 4, 11], "minim": [2, 4, 11, 13, 14, 15, 16, 17, 48, 56, 61, 63, 68], "transfer": [2, 38, 39], "subclass": [2, 20, 60], "cusvstat": 2, "scalartyp": [2, 67], "remotesimulationst": 2, "nvqir": [2, 17, 57, 58, 60], "mpssimulationst": 2, "tensornetsimulationst": 2, "made": [2, 11, 43, 53, 63], "up": [2, 3, 4, 6, 11, 12, 14, 22, 28, 39, 42, 48, 52, 53, 54, 56, 57, 60, 63], "extent": [2, 3, 39], "enum": 2, "precis": [2, 3, 12, 15, 37, 39, 55], "enumer": [2, 3, 13, 23, 45], "fp32": [2, 3, 37, 38, 39], "fp64": [2, 3, 15, 16, 35, 37, 38, 39], "simulation_precis": 2, "possibl": [2, 4, 6, 13, 14, 19, 34, 55, 63, 65, 67], "float": [2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 16, 20, 23, 24, 27, 31, 37, 38, 39, 48, 54, 56, 60], "tensorstatedata": 2, "dimens": [2, 3, 4, 5, 9, 11, 20, 54, 56], "state_data": 2, "variant": [2, 27], "custatevec": [2, 37, 38, 39, 60], "care": [2, 20, 67], "taken": [2, 4, 9], "ensur": [2, 57, 59, 61, 63, 67], "comparison": [2, 6], "compat": [2, 3, 26, 39, 61], "registeredtyp": 2, "declar": [2, 20, 24, 25, 27, 57, 60, 65, 67], "themselv": [2, 36, 41], "plugin": [2, 18, 59, 61, 63, 70], "myinterfac": 2, "column": [2, 3, 14], "upon": [2, 5, 34, 43, 49, 55, 63], "destruct": 2, "rawdata": 2, "intern": [2, 3, 38], "modifi": [2, 23, 24, 27, 31, 34, 39, 56, 63], "correct": [2, 12, 13, 23, 42, 49, 61, 63], "j": [2, 3, 4, 7, 9, 11, 12, 13, 23, 24, 28, 52, 54, 61], "minimal_eigenvalu": [2, 3], "eigenvalu": [2, 3, 11, 39, 56], "thei": [2, 3, 4, 5, 11, 24, 32, 34, 42, 55, 56, 61, 63], "set_zero": 2, "seen": [2, 6], "manag": [2, 14, 37, 38, 61, 63], "instruct": [2, 18, 25, 27, 29, 34, 36, 37, 39, 49, 50, 56, 57, 61, 63, 67, 68, 70], "control": [2, 3, 7, 11, 12, 17, 18, 19, 22, 23, 24, 25, 27, 29, 31, 32, 33, 34, 36, 38, 41, 42, 45, 47, 49, 50, 53, 55, 56, 57, 60, 63, 70], "flow": [2, 8, 19, 20, 24, 33, 42, 57], "path": [2, 3, 14, 36, 57, 60, 61, 63], "thu": [2, 37, 38, 39, 55, 57], "might": [2, 4, 22, 27, 34, 35, 37, 38, 51], "produc": [2, 3, 4, 11, 20, 23, 28, 29, 34, 41, 43, 50, 57, 60, 67], "elementtyp": 2, "is_integral_v": 2, "is_signed_v": 2, "increment": [2, 52], "exclus": [2, 6], "stop": [2, 43, 63], "step": [2, 4, 6, 8, 12, 23, 57, 61, 65, 68], "reach": [2, 52], "quantumkernel": [2, 20, 31], "arg": [2, 3, 4, 8, 12, 13, 20, 22, 27, 31, 38, 43, 57, 63], "is_invocable_v": 2, "draw": [2, 3, 4, 5, 6, 10, 12, 13, 14, 43, 45], "utf": [2, 3], "8": [2, 3, 4, 8, 9, 11, 12, 13, 14, 15, 16, 18, 20, 23, 24, 25, 35, 36, 37, 38, 39, 49, 52, 53, 54, 56, 57, 61, 63, 68, 70], "usag": [2, 38, 52], "iostream": [2, 37, 41, 43, 45, 67], "mz": [2, 3, 6, 7, 13, 20, 22, 23, 34, 36, 37, 38, 41, 43, 45, 46, 49, 50, 51, 52, 53, 55, 57, 67, 68], "cout": [2, 37, 43, 45, 67], "q0": [2, 3, 4, 5, 6, 10, 12, 14, 34], "q1": [2, 3, 4, 5, 6, 10, 12, 14, 34], "ry": [2, 3, 4, 5, 7, 8, 9, 20, 23, 24, 27, 29, 37, 38, 48, 56], "59": [2, 3, 11, 20, 23, 38, 48], "callabl": [2, 3, 19, 20, 22, 23, 24, 41, 48, 50], "trivial": [2, 4, 20, 38, 46, 48, 64], "signatur": [2, 3, 20, 22, 24, 51, 57], "evalu": [2, 3, 4, 7, 20, 37, 38, 39, 48], "without": [2, 3, 20, 24, 31, 36, 39, 45, 49, 53, 61, 63, 67, 68], "regard": 2, "depth": [2, 4, 69], "etc": [2, 24, 25, 38, 42, 56, 60, 61, 63, 68], "kraus_op": 2, "krau": [2, 3, 10, 53], "initializer_list": 2, "initlist": 2, "adjoint": [2, 12, 22, 23, 27, 31, 34, 57], "flatten": [2, 67], "nrow": [2, 8, 14], "ncol": [2, 14], "kraus_channel": [2, 53], "channel": [2, 3, 10, 13, 53, 63], "action": [2, 20, 23, 24, 63], "matric": [2, 3, 39], "amplitude_damping_channel": [2, 53], "bit_flip_channel": [2, 53], "depolarization_channel": [2, 10, 53], "phase_flip_channel": [2, 53], "inputlist": 2, "lvalu": 2, "make": [2, 3, 6, 12, 14, 20, 38, 39, 53, 54, 56, 57, 60, 61, 63, 65, 68], "get_op": 2, "push_back": [2, 24, 45], "autom": [2, 60], "creation": [2, 4, 19, 33, 56, 60], "damp": [2, 53], "phase": [2, 3, 12, 27, 49, 53], "depolar": [2, 3, 10, 53], "densiti": [2, 3, 10, 13, 14, 35, 37, 39, 53], "add_channel": [2, 3, 10, 13, 53], "quantumop": 2, "get_channel": [2, 3], "relev": [2, 4, 5, 8, 13, 16, 30, 39], "kernel_build": [2, 22], "kernel_builder_bas": 2, "kernelbuildertyp": 2, "mlir": [2, 3, 17, 38, 57, 58, 59, 61], "getargu": [2, 22, 59], "quakevalu": [2, 3, 22], "isargstdvec": 2, "otherwis": [2, 3, 6, 39, 43], "getnumparam": [2, 22], "qalloc": [2, 3, 22, 36, 37, 38, 52], "qvec": [2, 34, 36], "veq": [2, 3, 34, 57], "blockargu": 2, "object": [2, 3, 4, 9, 11, 13, 14, 20, 24, 34, 38, 43, 54, 56, 57], "simplic": 2, "impli": [2, 3, 39], "goe": [2, 25, 45], "scope": [2, 24, 25, 32, 57, 59], "befor": [2, 11, 14, 36, 44, 49, 53, 56, 61, 63], "mai": [2, 3, 4, 6, 11, 13, 20, 22, 24, 25, 27, 31, 32, 36, 37, 38, 39, 42, 43, 44, 46, 49, 51, 56, 61, 63, 65, 67, 68], "garbag": 2, "constantv": 2, "val": [2, 13, 49], "swap": [2, 14, 23, 49], "mod": [2, 27], "is_same_v": 2, "perform": [2, 4, 6, 8, 12, 13, 15, 18, 20, 23, 36, 38, 39, 43, 45, 49, 51, 52, 55, 59, 60, 61, 63, 67, 68, 70], "fredkin": 2, "between": [2, 3, 4, 7, 11, 13, 15, 24, 34, 37, 41, 42, 43, 49, 52, 53, 63, 65], "meant": [2, 19, 46], "thin": [2, 3], "wrapper": [2, 3, 38], "around": [2, 3, 6, 13, 20, 45, 53, 68], "instanc": [2, 3, 4, 20, 22, 27, 32, 37, 38, 39, 42, 63], "quak": [2, 3, 11, 17, 33, 57, 59], "dialect": [2, 3, 57, 59], "arithmet": [2, 24, 25, 56], "getvalu": 2, "actual": [2, 13, 20, 43, 60], "implicitlocopbuild": 2, "arith": [2, 34, 57], "constantfloatop": 2, "canvalidatenumel": 2, "stdvectyp": 2, "do": [2, 4, 12, 13, 18, 27, 29, 32, 34, 37, 38, 39, 41, 42, 50, 55, 57, 61, 63, 64, 65, 68, 70], "loop": [2, 3, 4, 11, 21, 32, 41, 49, 52, 54, 56, 57], "know": [2, 14, 18, 34, 70], "bound": [2, 3, 13, 56], "startidx": [2, 3], "subscript": [2, 3, 36, 37], "stdvec": [2, 34, 57], "constants": 2, "isstdvec": 2, "getrequiredel": 2, "veqtyp": 2, "divid": [2, 11], "invers": [2, 12, 23], "so": [2, 4, 7, 9, 11, 13, 14, 20, 36, 38, 39, 45, 50, 55, 56, 57, 59, 60, 61, 63, 67, 68], "friend": 2, "write": [2, 3, 44, 49, 55, 56, 59, 63, 65], "u": [2, 4, 5, 6, 9, 11, 12, 14, 15, 23, 24, 28, 29, 41, 42, 43, 51, 52, 53, 55, 56, 57], "wai": [2, 3, 6, 20, 31, 34, 43, 61], "code": [2, 3, 4, 6, 11, 12, 14, 15, 19, 20, 22, 23, 24, 25, 28, 29, 31, 32, 34, 36, 37, 38, 39, 43, 48, 49, 50, 52, 53, 55, 56, 57, 59, 60, 61, 64, 65, 67, 68], "mlircontext": 2, "ctx": [2, 8, 59], "f": [2, 4, 6, 13, 23, 24, 45, 48, 56, 61, 68], "high": [2, 13, 52, 57, 67], "serv": [2, 3, 4, 24, 32, 37, 59, 61], "work": [2, 4, 12, 13, 17, 20, 37, 38, 52, 56, 58, 61, 63, 64, 67, 68], "subtyp": 2, "possibli": [2, 24], "deleg": [2, 37, 60, 63], "third": [2, 3, 17, 56, 66], "parti": [2, 17, 56, 66], "immut": 2, "mutabl": [2, 20], "gradient": [2, 5, 8, 37, 54, 56], "df": [2, 13], "dx_i": 2, "scalar": [2, 20], "queri": [2, 6, 20, 30, 38, 45, 48], "whether": [2, 3, 61, 63], "strategi": [2, 20, 25, 31, 56, 60], "parameter": [2, 3, 4, 11, 15, 20, 22, 24, 27, 37, 42, 48, 50, 52, 56], "left": [2, 6, 7, 11, 12, 49, 60, 63], "thing": [2, 51, 56], "max": [2, 4, 9, 17, 37, 39, 49, 54], "cobyla": [2, 3, 4, 5, 9, 15, 16, 20, 54, 56], "opt": [2, 24, 57, 59, 61, 63], "assert": [2, 23, 24], "requiresgradi": [2, 20], "algo": 2, "opt_val": [2, 37, 54, 56], "opt_param": [2, 20, 37, 54, 56], "dx": [2, 20], "virtual": [2, 14, 18, 20, 37, 38, 43, 48, 52, 60, 61, 70], "achiev": [2, 11, 12, 20, 36, 37, 51, 56], "dim": [2, 37], "optimizable_funct": [2, 20], "opt_funct": [2, 20, 37], "variat": [2, 4, 5, 8, 11, 16, 17, 20, 47], "custom": [2, 10, 18, 20, 24, 38, 39, 50, 53, 56, 59, 61, 63, 66, 67, 70], "ptrtoown": 2, "conveni": [2, 12, 28, 34, 56, 61, 63], "jdx": 2, "tensoridx": 2, "get_tensor": 2, "just": [2, 4, 6, 7, 11, 19, 33, 38, 43, 44, 45, 50, 55, 57, 63], "rank": [2, 3, 38, 46, 50, 52], "get_num_tensor": 2, "get_num_qubit": [2, 30], "get_precis": [2, 3], "is_on_gpu": [2, 3], "to_host": 2, "hostptr": 2, "numel": 2, "pure": [2, 10, 23, 24, 31, 56], "basisst": 2, "host": [2, 21, 23, 24, 25, 28, 32, 37, 38, 39, 48, 67, 68], "leverag": [2, 3, 4, 20, 22, 24, 27, 31, 32, 39, 50, 54, 56, 57, 60, 64], "separ": [2, 4, 39, 61, 63], "mapper": 2, "inherit": [2, 21, 25, 38], "updat": [2, 4, 20, 36, 49, 61, 68], "protect": [2, 32, 60], "getexpectedvalu": 2, "central_differ": [2, 20, 56], "forward_differ": 2, "parameter_shift": 2, "prescrib": 2, "kernelt": 2, "argsmapp": [2, 20], "setarg": 2, "save": [2, 8, 37, 38, 43, 52, 57, 63, 65], "nvqc": [2, 35, 37], "setkernel": 2, "been": [2, 3, 14, 36, 37, 42, 43, 49, 61, 63], "have": [2, 3, 4, 6, 11, 12, 13, 14, 18, 20, 34, 37, 38, 39, 43, 45, 49, 52, 53, 55, 59, 61, 63, 64, 65, 67, 68, 70], "funcatx": [2, 3], "func": [2, 20, 34, 57, 59], "clone": [2, 8, 32, 59, 61], "deriv": [2, 4, 6, 20, 55], "exp_h": [2, 20], "forward": [2, 8], "approxim": [2, 4, 11, 17, 39, 43, 47], "registri": [2, 63], "unit": [2, 3, 19, 24, 25, 27, 30, 32, 36, 42, 55], "express": [2, 18, 20, 21, 22, 23, 25, 28, 38, 42, 50, 51, 57, 67, 70], "certain": [2, 32, 37, 38, 39, 60, 63], "logic": [2, 6, 30, 32, 38], "connect": [2, 4, 8, 11, 18, 25, 30, 32, 34, 49, 61, 70], "queue": [2, 20, 37, 49], "enqueu": 2, "relat": [2, 4, 11, 57], "quantum_platform": [2, 3, 30, 38, 48, 57], "baseremoterestqpu": 2, "baseremotesimulatorqpu": 2, "_qpuid": 2, "setid": 2, "thread": [2, 3, 25, 38, 39, 48, 52, 60], "getexecutionthreadid": 2, "getnumqubit": 2, "getconnect": 2, "issimul": 2, "supportsconditionalfeedback": 2, "feedback": [2, 25, 42, 63], "remotecap": 2, "getremotecap": 2, "capabl": [2, 37, 39, 52, 61, 63], "setshot": 2, "_nshot": 2, "noth": 2, "wish": [2, 4, 37, 38, 48, 63], "isemul": 2, "local": [2, 3, 14, 17, 36, 37, 38, 43, 46, 49, 57, 61, 62, 64], "emul": [2, 3, 36, 49], "quantumtask": 2, "setexecutioncontext": 2, "resetexecutioncontext": 2, "reset": [2, 3, 20, 23, 25, 39, 60], "launchkernel": 2, "kernelfunc": 2, "uint64_t": 2, "launch": [2, 20, 38, 39, 63, 68], "pack": [2, 67], "launchserializedcodeexecut": 2, "serializedcodeexecutioncontext": 2, "serializecodeexecutionobject": 2, "onrandomseedset": 2, "notifi": 2, "let": [2, 6, 7, 10, 11, 12, 13, 14, 15, 27, 34, 41, 42, 43, 46, 48, 50, 51, 52, 53, 54, 55, 56, 57, 63, 64, 65, 68], "basenvcfsimulatorqpu": 2, "submit": [2, 36, 37, 49, 63], "nvcf": 2, "realiz": [2, 55], "intend": [2, 19, 20, 22, 61, 65], "popul": [2, 45], "platformqpu": 2, "qubitconnect": [2, 30], "fetch": [2, 4], "supports_task_distribut": 2, "multipl": [2, 4, 13, 14, 16, 18, 27, 36, 38, 39, 42, 43, 49, 51, 55, 70], "parallel": [2, 19, 25, 39, 43, 63, 68], "qpu_id": [2, 3, 7, 20, 30, 37, 38, 43, 52], "get_shot": 2, "getter": 2, "onc": [2, 4, 12, 13, 22, 36, 37, 39, 42, 43, 49, 61, 63, 65, 68], "set_shot": 2, "clear_shot": 2, "remov": [2, 4, 34, 35, 37, 38, 39, 63], "numshot": 2, "setter": 2, "set_exec_ctx": 2, "get_exec_ctx": 2, "reset_exec_ctx": 2, "num_qpu": [2, 3, 7, 30, 37, 38, 48], "is_simul": [2, 30], "supports_conditional_feedback": 2, "get_current_qpu": [2, 30], "set_current_qpu": [2, 30], "device_id": [2, 30], "is_remot": [2, 3, 30], "qpuid": [2, 30, 38], "is_emul": [2, 3, 30], "set_nois": [2, 3, 53], "get_remote_cap": 2, "applic": [2, 4, 6, 11, 12, 13, 15, 17, 20, 27, 31, 36, 39, 42, 43, 47, 63, 64, 67, 68, 69], "reset_nois": 2, "turn": [2, 8, 12, 14, 37, 44, 60], "off": [2, 3, 4, 8, 12, 37, 38, 61], "enqueueasynctask": 2, "kernelexecutiontask": 2, "launchvq": 2, "kernelarg": 2, "n_param": [2, 54, 56], "vqe": [2, 3, 4, 11, 15, 37, 54, 56], "settargetbackend": 2, "resetlogstream": 2, "log": [2, 3, 18, 37, 61, 63, 70], "getlogstream": 2, "setlogstream": 2, "logstream": 2, "list_platform": 2, "structur": [2, 3, 4, 8, 11, 20, 22, 26, 28, 30, 32, 38, 39, 57, 59, 60, 65], "boolean": [2, 22], "field": [2, 11, 38], "initvalu": 2, "stateoverlap": 2, "serializedcodeexec": 2, "command": [2, 4, 37, 38, 39, 43, 45, 46, 48, 49, 52, 60, 61, 63, 64, 65, 67, 68], "entir": [2, 14, 34, 50, 56, 60], "forth": [2, 38], "commun": [2, 20, 36, 38, 39, 61], "ultim": [2, 57, 60], "what": [2, 3, 4, 11, 13, 14, 17, 18, 40, 52, 60, 67, 70], "ad": [2, 13, 18, 20, 36, 37, 50, 53, 57, 61, 63, 65, 68, 70], "promis": 2, "qubitedg": [2, 30], "num_available_gpu": [2, 3, 43, 52], "set_random_se": [2, 3, 8, 9, 11, 13, 39, 54, 56], "caller": [2, 24], "unset_nois": [2, 3, 53], "dealloc": [2, 25, 32, 60], "mpi": [2, 18, 38, 39, 46, 50, 52, 68, 70], "against": [2, 18, 36, 61, 65, 70], "argc": [2, 23, 43, 61, 68], "argv": [2, 23, 43, 61, 68], "program": [2, 17, 19, 22, 24, 27, 32, 33, 36, 37, 38, 39, 40, 42, 49, 50, 52, 53, 57, 61, 63, 65, 68], "is_initi": [2, 3, 46, 50], "alreadi": [2, 3, 14, 61, 63, 68], "final": [2, 3, 4, 5, 38, 48, 50, 52, 56, 57, 60, 61], "num_rank": [2, 3, 52], "all_gath": [2, 3], "gather": [2, 3, 23, 43, 55], "fit": [2, 61], "come": [2, 25, 37, 49, 67], "all_reduc": 2, "binaryfunct": 2, "localvalu": 2, "reduc": [2, 7, 13, 39], "rootrank": [2, 3], "make_kernel": [3, 22, 36, 37, 38, 52], "els": [3, 4, 8, 14, 22, 38, 39, 43, 61, 65, 68], "int_valu": 3, "float_valu": 3, "pykernel": 3, "argtypelist": 3, "programmat": 3, "str": [3, 4, 9, 13, 36, 38, 43, 45, 49, 55, 67], "argument_count": 3, "alia": [3, 32], "pykerneldecor": 3, "verbos": [3, 40, 57, 61, 64], "modul": [3, 8, 39, 43, 56, 57, 61], "none": [3, 8, 23, 24, 39], "funcsrc": 3, "locat": [3, 36, 38, 61, 63, 67], "overrideglobalscopedvar": 3, "decor": [3, 4, 24, 41], "lower": [3, 57, 60], "ast": 3, "jit": [3, 4], "executionengin": 3, "__call__": 3, "__str__": 3, "from_json": 3, "jstr": 3, "overridedict": 3, "convert": [3, 4, 20, 48, 57], "json": [3, 36, 38, 49, 63], "to_json": 3, "self": [3, 4, 8, 11, 24, 61, 63], "reconstruct": 3, "elsewher": 3, "type_to_str": 3, "clean": 3, "kwarg": [3, 4], "languag": [3, 17, 18, 21, 24, 25, 26, 27, 32, 33, 38, 42, 50, 55, 57, 60, 64, 70], "attribut": [3, 24, 50, 57], "coprocessor": [3, 20, 24], "shots_count": [3, 4, 6, 7, 9, 10, 13, 36, 43, 46, 50, 52], "over": [3, 10, 20, 32, 43, 49, 53, 54, 56, 60, 63], "ndarrai": [3, 8, 10, 14], "leav": [3, 10, 36, 49, 63], "doesn": 3, "firstfloat": 3, "secondfloat": 3, "kei": [3, 9, 11, 12, 13, 29, 36, 37, 60, 63, 68], "nois": [3, 4, 10, 20, 30, 36, 49, 53], "model": [3, 4, 10, 17, 19, 20, 22, 24, 27, 32, 33, 34, 36, 38, 49, 53, 57, 60, 63, 68], "dictionari": [3, 13, 20, 43, 50, 56], "sampleresult": [3, 4, 43, 50, 60], "sample_async": [3, 7, 20, 38, 43, 49], "_mlir_lib": 3, "_quakedialect": 3, "cudaq_runtim": 3, "asyncsampleresult": [3, 49], "platform": [3, 17, 18, 19, 27, 33, 35, 36, 37, 39, 43, 48, 52, 57, 60, 61, 63, 68, 70], "Will": [3, 29, 43], "whose": [3, 8, 11, 14, 15, 20, 25, 37, 38, 48, 55], "identif": 3, "spin_oper": [3, 11, 43, 48, 56], "spinoper": [3, 4, 8, 9, 11, 16, 43, 48, 52, 56], "everi": [3, 11, 13, 18, 37, 38, 42, 43, 49, 50, 61, 68, 70], "nest": [3, 38], "hermitian": 3, "calcul": [3, 4, 5, 6, 7, 8, 37, 38, 43, 49, 52, 56], "observeresult": [3, 43, 56], "observe_async": [3, 20, 37, 52], "asyncobserveresult": 3, "arg0": [3, 57], "prepar": [3, 4, 7, 8, 12, 13, 15, 45, 48, 50, 52, 54], "select": [3, 4, 8, 15, 39, 43, 46, 48, 63, 67], "get_state_async": [3, 38], "asyncstateresult": 3, "parameter_count": [3, 4, 9, 11, 15, 16, 52, 54, 56], "argument_mapp": [3, 11], "gradient_strategi": [3, 56], "arg1": 3, "format": [3, 8, 14, 20, 23, 32, 61], "ascii": [3, 14], "latex": [3, 14], "cx": [3, 4, 13, 22, 36, 37, 45, 52, 68], "translat": [3, 20, 55, 57], "qir": [3, 57, 60], "adapt": [3, 11, 18, 70], "openqasm2": 3, "openqasm": 3, "moduleid": [3, 57], "llvmdialectmodul": [3, 57], "source_filenam": [3, 57], "opaqu": [3, 32, 57], "__nvqpp__mlirgen__function_variable_qreg": 3, "_z13variable_qregv": 3, "local_unnamed_addr": [3, 57], "tail": [3, 57], "__quantum__rt__qubit_allocate_arrai": [3, 57], "i64": [3, 57], "__quantum__qis__mz": [3, 57], "9": [3, 4, 8, 9, 13, 14, 20, 24, 25, 57, 61, 63], "7": [3, 4, 5, 7, 8, 9, 11, 12, 13, 14, 18, 20, 24, 25, 27, 32, 38, 52, 57, 61, 63, 70], "__quantum__rt__qubit_release_arrai": [3, 57], "ret": [3, 57], "has_target": 3, "get_target": [3, 7, 37, 38, 48, 68], "rais": 3, "set_target": [3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 36, 37, 38, 39, 43, 45, 46, 48, 49, 52, 53, 60], "reset_target": 3, "initialize_cudaq": 3, "environ": [3, 4, 10, 14, 18, 36, 37, 38, 44, 46, 49, 59, 61, 63, 68, 70], "detect": [3, 43, 52, 61, 63, 67], "simulationprecis": 3, "underyl": 3, "properti": [3, 4, 6, 34], "noindex": 3, "infrastructur": [3, 18, 38, 59, 61, 70], "descript": [3, 37, 39, 60, 61, 63], "featur": [3, 4, 12, 18, 24, 61, 63, 67, 68, 70], "activ": [3, 8, 17, 38, 39, 61, 63, 68], "consist": [3, 4, 43], "physic": [3, 11, 19, 25, 32, 34, 36, 38, 39, 49, 55], "0101": [3, 54], "1010": [3, 54], "consol": [3, 37, 44, 61], "cupi": [3, 63], "gettensor": 3, "compris": 3, "tensori": 3, "mlirvalu": 3, "As": [3, 11, 19, 25, 26, 32, 38, 39, 41, 55, 56, 59], "hold": [3, 56], "__add__": 3, "runtimeerror": [3, 4], "new_valu": 3, "5": [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 22, 23, 24, 25, 27, 28, 31, 32, 37, 38, 39, 45, 46, 48, 49, 52, 53, 54, 56, 57, 61, 63, 65, 70], "__radd__": 3, "__sub__": 3, "__rsub__": 3, "__neg__": 3, "__mul__": 3, "__rmul__": 3, "__getitem__": 3, "you": [3, 4, 6, 12, 13, 14, 17, 18, 20, 36, 37, 39, 43, 45, 49, 50, 52, 53, 56, 57, 59, 60, 61, 63, 64, 65, 67, 68, 70], "complexmatrix": 3, "lowest": 3, "__eq__": 3, "togeth": [3, 13, 17, 39, 57, 68], "__iter__": 3, "through": [3, 4, 6, 8, 10, 20, 36, 41, 44, 46, 50, 53, 56, 60, 61, 63, 68], "chunk_count": 3, "d1": 3, "d2": [3, 48], "d3": 3, "receiv": [3, 20], "while": [3, 18, 24, 42, 43, 49, 57, 61, 63, 67, 70], "0j": [3, 7, 9, 11, 43], "get_qubit_count": 3, "get_term_count": [3, 16], "qubit_count": [3, 6, 8, 10, 11, 12, 15, 16, 38, 41, 43, 45, 46, 52, 54, 68], "term_count": [3, 52], "1183127353": 3, "ith": 3, "scipi": [3, 13, 14, 15, 16, 56], "csr_arrai": 3, "print_coeffici": 3, "termin": [3, 52, 63], "At": [3, 61, 63], "directli": [3, 19, 20, 25, 32, 34, 57, 63, 67, 68], "c_if": [3, 22], "dure": [3, 5, 10, 20, 36, 39, 61, 63, 67], "__len__": 3, "equival": [3, 11, 38, 39, 43], "metadata": [3, 15, 57], "experi": [3, 4, 13, 36, 49, 61, 63], "expectation_z": 3, "get_marginal_count": [3, 13], "marginal_indic": 3, "get_register_count": 3, "get_sequential_data": 3, "item": [3, 8, 13, 67], "frequent": 3, "proport": 3, "kick": [3, 38], "pattern": [3, 4, 19, 20, 24, 33, 57, 59], "sub_term": 3, "favor": 3, "get_spin": 3, "accessor": [3, 38], "optimizationresult": 3, "gradientdesc": 3, "initial_paramet": [3, 4, 5, 9, 11, 54, 56], "lower_bound": 3, "max_iter": [3, 4, 56], "maximum": [3, 4, 39], "requires_gradi": 3, "upper_bound": 3, "upper": 3, "neldermead": [3, 9, 11], "lbfg": [3, 20, 37, 56], "centraldiffer": [3, 56], "parameter_vector": [3, 4, 11, 37, 56], "loss": 3, "forwarddiffer": 3, "parametershift": 3, "krauschannel": [3, 10, 53], "__init__": [3, 4, 8, 24], "bitflipchannel": [3, 13, 53], "decoher": [3, 10, 53], "Its": [3, 32, 39, 55, 57], "vice": 3, "versa": 3, "180": [3, 53], "therebi": [3, 20, 38, 57], "k_0": [3, 10], "k_1": [3, 10], "therefor": [3, 11, 12, 32, 57, 59], "phaseflipchannel": [3, 53], "untouch": 3, "depolarizationchannel": [3, 10, 53], "mixtur": 3, "k_2": 3, "k_3": 3, "2x2": [3, 39], "decai": [3, 10, 53], "And": [3, 11, 34], "behav": 3, "free": [3, 4, 5, 11, 20, 22, 23, 24, 25, 27, 29, 31, 36, 37, 41, 50, 54, 56, 57, 60, 63], "75": [3, 4, 12, 16], "proabil": 3, "uniform": [3, 4, 9, 11, 13, 20, 23, 43, 52, 54], "amplitudedampingchannel": [3, 53], "dissip": [3, 53], "energi": [3, 4, 15, 16, 20, 37, 48, 53, 56], "due": [3, 4, 10, 14, 15, 20, 39, 43, 53, 67], "interact": [3, 30, 53, 63], "ii": [3, 11], "ground": [3, 4, 15, 37, 53, 55, 56], "krausoper": [3, 53], "ki": 3, "dag": [3, 14, 29], "col_count": 3, "row_count": 3, "scatter": [3, 4], "concaten": 3, "arg2": 3, "tutori": [4, 11, 13, 63], "explor": [4, 52, 55, 63], "recent": 4, "research": [4, 37], "arxiv": 4, "paper": [4, 9, 54], "http": [4, 8, 11, 12, 14, 36, 38, 49, 61, 63], "org": [4, 61, 63], "pdf": [4, 14], "2402": 4, "01529": 4, "team": 4, "edinburgh": 4, "jointli": 4, "develop": [4, 17, 24, 25, 36, 37, 39, 47, 55, 59, 60, 61, 64, 68], "nvidia": [4, 5, 6, 7, 8, 9, 11, 12, 15, 16, 17, 18, 19, 25, 35, 39, 43, 45, 46, 48, 52, 60, 61, 63, 65, 68, 70], "author": 4, "better": [4, 11, 13, 37, 39, 61], "understand": [4, 13, 19, 63], "barrier": 4, "mit": 4, "licens": [4, 61, 63], "found": [4, 14, 18, 20, 23, 27, 36, 43, 60, 61, 63, 65, 66, 68, 70], "github": [4, 8, 11, 12, 18, 36, 39, 61, 63, 68, 70], "com": [4, 8, 11, 12, 36, 49, 61, 63], "boniface316": 4, "bigdata_vqa": 4, "unsupervis": 4, "learn": [4, 8, 11, 14, 18, 37, 42, 43, 67, 68, 70], "techniqu": [4, 39, 43], "aim": [4, 6, 11, 45], "group": [4, 32, 39], "similar": [4, 20, 38, 43, 61], "characterist": 4, "enhanc": 4, "find": [4, 6, 11, 13, 15, 17, 36, 37, 38, 55, 56, 57, 61, 63], "reliabl": [4, 67], "analysi": [4, 34, 57], "todai": 4, "sever": [4, 50, 53], "limit": [4, 38, 39, 43, 52, 67], "practic": [4, 6, 13, 53], "would": [4, 6, 11, 12, 18, 34, 52, 55, 61, 63, 65, 67, 70], "far": 4, "too": [4, 14, 46, 55], "mani": [4, 12, 18, 27, 30, 38, 39, 43, 52, 68, 70], "extend": [4, 12, 14, 17, 18, 19, 66, 70], "harrow": 4, "fewer": [4, 39], "walk": [4, 60, 61, 63], "approach": [4, 12, 13, 20, 24, 57], "emphas": 4, "util": [4, 8, 10, 20, 32, 37, 38, 39, 52, 57, 60], "bipartit": 4, "branch": [4, 18, 22, 61, 63, 70], "directori": [4, 59, 61, 63, 67], "tree": 4, "uncom": [4, 11, 61, 63], "line": [4, 11, 14, 36, 38, 39, 45, 49, 57, 60, 61, 63], "insid": [4, 38, 63], "skip": [4, 14, 61], "mkdir": [4, 60, 61, 64], "divisive_clustering_src": 4, "wget": [4, 61, 63], "p": [4, 7, 9, 10, 13, 53, 54, 61, 63], "githubusercont": 4, "doc": [4, 38], "sphinx": 4, "divisive_clust": 4, "py": [4, 16, 38, 39, 43, 44, 52, 56, 63, 68], "main_divisive_clust": 4, "instal": [4, 5, 8, 13, 14, 15, 16, 17, 18, 36, 39, 57, 59, 60, 64, 65, 67, 70], "packag": [4, 5, 6, 8, 13, 14, 16, 61, 63, 67, 68], "pip": [4, 5, 8, 13, 14, 15, 16, 38, 39, 61, 63, 68], "mpi4pi": [4, 39, 68], "6": [4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 23, 24, 25, 27, 28, 32, 36, 37, 38, 39, 48, 49, 56, 57, 63, 70], "networkx": 4, "panda": [4, 13], "scikit": [4, 8], "tqdm": 4, "66": [4, 9], "auxillari": [4, 45], "nx": 4, "pd": [4, 13], "matplotlib": [4, 5, 8, 9, 13, 14, 15, 16], "pyplot": [4, 5, 8, 9, 13, 14, 15, 16], "plt": [4, 5, 8, 9, 13, 14, 15, 16], "warn": [4, 14, 16, 36], "divisiveclust": 4, "dendrogram": 4, "voironi_tessal": 4, "filterwarn": 4, "below": [4, 5, 6, 8, 11, 12, 15, 18, 20, 36, 37, 38, 39, 43, 49, 52, 54, 56, 57, 61, 63, 67, 68, 70], "toggl": 4, "circuit_depth": 4, "max_shot": 4, "x_1": 4, "x_2": 4, "cdot": 4, "x_n": 4, "weight": [4, 9], "much": [4, 56, 60], "smaller": [4, 39], "w": [4, 29, 39, 49], "enough": 4, "reason": [4, 34], "conclus": 4, "There": [4, 20, 22, 36, 37, 38, 52, 63], "variou": [4, 18, 38, 41, 50, 53, 57, 60, 70], "build": [4, 5, 11, 13, 14, 15, 17, 18, 22, 27, 28, 40, 42, 43, 48, 54, 55, 56, 59, 60, 63, 64, 65, 67, 70], "machin": [4, 11, 19, 33, 36, 38, 49, 63], "1703": 4, "06476": 4, "algorithm": [4, 5, 11, 12, 15, 17, 19, 22, 24, 33, 34, 37, 38, 39, 43, 45, 47, 48, 51, 56, 63], "essenti": 4, "boil": 4, "down": [4, 38], "toler": 4, "constraint": [4, 13, 24, 25, 26, 39, 43, 49, 55], "priori": 4, "load": [4, 8, 20, 25, 36, 37, 49, 57, 59], "frame": 4, "imag": [4, 8, 11, 18, 49, 61, 68, 70], "black": [4, 6], "star": 4, "create_dataset": 4, "number_of_sampling_for_centroid": 4, "coreset_s": 4, "number_of_coresets_to_evalu": 4, "coreset_method": 4, "bfl2": 4, "coreset_vector": 4, "coreset_weight": 4, "get_best_coreset": 4, "coreset_df": 4, "datafram": [4, 13], "chr": 4, "65": [4, 11, 13], "028364": 4, "669787": 4, "234": [4, 13], "230716": 4, "167441": 4, "354792": 4, "101": [4, 12, 13, 23], "319288": 4, "b": [4, 20, 49], "022889": 4, "921443": 4, "125": [4, 20, 23, 28, 37, 38, 48, 56], "158339": 4, "706134": 4, "636852": 4, "13": [4, 8, 9, 11, 13, 15, 16, 52, 54, 56, 57, 63], "650774": 4, "998497": 4, "455847": 4, "116": 4, "758239": 4, "507918": 4, "630311": 4, "120": [4, 63], "727176": 4, "102508": 4, "297727": 4, "53": [4, 13, 14], "294127": 4, "722463": 4, "400433": 4, "77": [4, 13], "415840": 4, "425868": 4, "341136": 4, "42": [4, 8, 13, 15, 16], "847985": 4, "985373": 4, "063209": 4, "240": 4, "116237": 4, "label": [4, 8, 13, 57, 61, 68], "7eba00": 4, "color": [4, 11], "marker": 4, "xlabel": [4, 5, 8, 9, 15, 16], "ylabel": [4, 5, 8, 9, 15, 16], "titl": [4, 15, 16, 36, 56, 63, 68], "best": [4, 12, 61, 63], "legend": [4, 8], "In": [4, 6, 10, 11, 13, 14, 20, 24, 34, 36, 38, 39, 41, 43, 45, 48, 49, 50, 53, 56, 59, 60, 61, 67], "cast": [4, 16], "problem": [4, 11, 12, 15, 34, 42, 54], "routin": [4, 11, 20, 56], "graph": [4, 9, 11, 54], "edg": [4, 9, 11], "e_": 4, "ij": 4, "w_iw_jd_": 4, "d_": 4, "euclidean": 4, "distanc": [4, 13, 15], "coreset_to_graph": 4, "vqa": 4, "hamiltonian": [4, 5, 7, 8, 9, 10, 11, 15, 16, 23, 37, 38, 39, 43, 48, 54, 56], "src": [4, 36, 61], "motiv": [4, 33, 61], "cut": [4, 17, 54], "get_k2_hamiltonian": 4, "k2": 4, "layer": [4, 8, 11, 24, 54, 56], "r_z": 4, "r_y": 4, "cascad": 4, "benefit": [4, 18, 43, 68, 70], "get_vqe_circuit": 4, "number_of_qubit": 4, "theta_posit": 4, "rz": [4, 11, 14, 23, 27, 54], "visual": [4, 11, 17, 34, 47], "rand": [4, 45], "8904": 4, "7335": 4, "4343": 4, "2236": 4, "7937": 4, "9981": 4, "3945": 4, "q2": [4, 5, 12, 14], "696": 4, "3352": 4, "q3": [4, 14], "6658": 4, "05277": 4, "q4": 4, "791": 4, "003569": 4, "4119": 4, "3205": 4, "3504": 4, "3913": 4, "7392": 4, "3171": 4, "0008056": 4, "proper": 4, "get_optim": 4, "addit": [4, 6, 12, 20, 37, 41, 42, 45, 52, 61, 67, 68], "initial_param": 4, "divisiveclusteringvqa": 4, "procedur": [4, 5, 15], "top": [4, 6, 13, 38, 60, 64], "pleas": [4, 14, 16, 18, 37, 38, 39, 49, 52, 59, 61, 63, 68, 70], "run_divisive_clust": 4, "get_counts_from_simul": 4, "cost": [4, 8, 9, 11, 15, 16, 17, 20, 37, 56], "our": [4, 5, 6, 10, 11, 14, 18, 34, 36, 41, 43, 45, 49, 50, 51, 52, 53, 56, 57, 61, 63, 64, 65, 68, 70], "obtain": [4, 13, 14, 15, 18, 37, 61, 70], "acceler": [4, 8, 17, 18, 37, 39, 43, 45, 46, 52, 60, 61, 63, 68, 70], "associ": [4, 11, 25, 38, 55], "super": [4, 8], "coreset_vectors_df_for_iter": 4, "coreset_vectors_for_iteration_np": 4, "coreset_weights_for_iteration_np": 4, "_get_iteration_coreset_vectors_and_weight": 4, "metric": 4, "coreset_to_graph_metr": 4, "_get_best_bitstr": 4, "len": [4, 5, 7, 8, 9, 11, 12, 13, 16, 23, 32, 38, 43, 45, 49, 52, 68], "node": [4, 9, 11, 19, 38, 52, 61], "create_hamiltonian": 4, "optimizer_funct": 4, "create_circuit": 4, "objective_funct": [4, 56], "get_result": [4, 56], "optimal_paramet": [4, 9, 11, 37, 54], "mostli": 4, "previous": [4, 36, 63], "threshold_for_max_cut": 4, "percent": 4, "advanc": [4, 56], "normal": [4, 8, 15, 16, 55], "get_divisive_sequ": 4, "analyz": [4, 59], "postprocess": 4, "sourc": [4, 10, 11, 13, 18, 34, 39, 45, 53, 57, 60, 63, 64, 65, 68, 70], "12": [4, 8, 13, 14, 20, 37, 57, 61, 63], "normalize_vector": 4, "sort_by_descend": 4, "dist": [4, 13, 14, 67], "hierarchial_clustering_sequ": 4, "100": [4, 8, 10, 13, 16, 23, 46], "129": 4, "lt": 4, "12075": 4, "19it": 4, "35025": 4, "50it": 4, "18": [4, 7, 13, 57], "44254": 4, "09it": 4, "15827": 4, "56it": 4, "13617": 4, "87it": 4, "nice": 4, "earli": [4, 37, 63], "split": [4, 52], "mark": [4, 67], "least": [4, 11, 38, 61], "dendo": 4, "plot_dendrogram": 4, "plot_titl": 4, "plot": [4, 5, 8, 9, 13, 15, 16], "notic": [4, 11, 34, 45, 46, 52, 57, 64], "complic": [4, 28], "becom": [4, 13, 39, 48, 63, 64], "occasion": 4, "especi": 4, "partit": [4, 9, 11, 37, 38, 63], "puzzl": 4, "glanc": 4, "seem": [4, 46, 55, 63, 68], "natur": [4, 14, 39, 55], "strai": 4, "belong": 4, "wrong": 4, "explan": 4, "stochast": [4, 20], "few": [4, 11], "were": [4, 45, 56, 63], "rememb": [4, 6], "pai": [4, 12], "penalti": [4, 9], "exclud": [4, 37, 43, 45, 61], "proxim": 4, "small": [4, 13, 39, 67], "less": [4, 53, 61], "impact": [4, 10, 53], "usual": [4, 61, 63, 67], "look": [4, 14, 18, 34, 36, 38, 42, 43, 46, 48, 49, 50, 51, 52, 53, 56, 57, 61, 63, 70], "unusu": 4, "go": [4, 6, 14, 32, 38, 50, 61, 63], "origin": [4, 10, 34, 45, 56, 57], "14": [4, 7, 13, 37, 49, 57], "plot_hierarchial_split": 4, "hierarch": 4, "flat": [4, 38], "perpendicular": 4, "intersect": 4, "threshold": [4, 39], "height": 4, "want": [4, 7, 11, 13, 14, 34, 37, 38, 57, 60, 61, 63, 65, 68], "get_clusters_using_k": 4, "desir": [4, 30, 38, 43, 60, 61, 63, 65], "figur": [4, 6, 8, 12, 57], "15": [4, 13, 52, 56, 57, 61, 63], "threshold_height": 4, "get_clusters_using_height": 4, "red": [4, 13], "blue": 4, "green": [4, 11], "purpl": 4, "orang": 4, "yellow": 4, "color_threshold": 4, "plot_clust": 4, "16": [4, 13, 14, 37, 56, 57], "show_annot": 4, "get_voronoi_tessal": 4, "region": 4, "accord": 4, "centroid": 4, "tesslation_by_clust": 4, "complet": [4, 10, 20, 36, 61, 63, 67, 68], "plot_voironi": 4, "overlai": 4, "17": [4, 8, 13, 57, 65], "vt": 4, "voironi": 4, "tessal": 4, "design": [4, 11, 17, 19, 38, 68], "flexibl": [4, 41, 61], "tool": [4, 13, 14, 18, 34, 57, 59, 61, 65, 67, 70], "done": [4, 14, 32, 44, 53, 61, 63], "get_qaoa_circuit": 4, "rx": [4, 5, 7, 8, 9, 11, 13, 14, 27, 31, 52, 54], "3527": 4, "19": [4, 7, 13, 37, 57], "20": [4, 7, 13, 26, 32, 56, 57, 65, 68], "484": 4, "12163": 4, "89it": 4, "52703": 4, "30it": 4, "48": 4, "31987": 4, "07it": 4, "36393": 4, "37957": 4, "42473": 4, "96it": 4, "quickli": [4, 20, 63], "encount": [4, 37, 39, 49, 61, 63, 68], "challeng": 4, "port": [4, 38, 63], "hpc": [4, 18, 63, 70], "becam": 4, "massiv": 4, "25": [4, 8, 12, 13, 23, 37, 38, 39, 43, 52, 63], "present": [4, 11, 13, 43, 46, 61, 64], "compar": [4, 42, 43, 45, 46, 63, 68], "your": [4, 14, 17, 20, 36, 37, 38, 39, 40, 45, 48, 49, 52, 53, 56, 60, 61, 63, 67], "100000": [4, 7, 52], "try": [4, 12, 14, 52, 63], "slightli": [4, 56], "qpp": [4, 8, 9, 11, 12, 16, 35, 37, 39, 43, 52, 57, 60, 63, 68], "python3": [4, 14, 38, 39, 43, 44, 52, 61, 63, 68], "751": 4, "3460": 4, "26it": 4, "42771": 4, "74it": 4, "4064": 4, "6862": 4, "37it": 4, "56871": 4, "92it": 4, "44979": 4, "13it": 4, "128": [4, 8, 57], "19366": 4, "94it": 4, "53773": 4, "54648": 4, "91it": 4, "51941": 4, "85it": 4, "56111": 4, "461": 4, "866833317": 4, "spent": 4, "452308367999706": 4, "oner": 4, "feel": 4, "interrupt": 4, "patienc": 4, "worn": 4, "still": [4, 24, 34, 43, 49, 53, 55, 63, 67], "easili": [4, 11, 43, 45, 46, 56, 61, 63, 67], "27": [4, 13, 43], "7352": 4, "03": [4, 37], "2063": 4, "82it": 4, "16492": 4, "4739": 4, "44it": 4, "256": [4, 8], "15185": 4, "58it": 4, "64": [4, 8, 38, 39, 57, 61, 63], "23728": 4, "05it": 4, "15437": 4, "97it": 4, "50840": 4, "32": [4, 8, 13, 36, 39, 57, 63], "33562": 4, "54120": 4, "54560": 4, "55924": 4, "42717": 4, "29it": 4, "55007": 4, "27it": 4, "53601": 4, "33it": 4, "47127": 4, "01it": 4, "67": 4, "61674502899999": 4, "21": [4, 7, 13, 57], "439895901": 4, "push": [4, 67], "34": [4, 13], "a100": 4, "yourself": [4, 61], "28": [4, 8, 13, 14, 16, 18, 38, 46, 61, 63, 68, 70], "nlopt": [4, 57], "failur": [4, 67], "To": [4, 10, 11, 12, 13, 20, 24, 27, 32, 36, 37, 38, 39, 42, 43, 46, 48, 49, 50, 53, 57, 59, 60, 61, 63, 64, 65, 67, 68], "pool": [4, 37, 52], "finish": [4, 43, 57], "fail": [4, 39, 59, 63, 67], "immedi": [4, 38, 60], "issu": [4, 20, 39, 61, 63, 67], "30": [4, 8, 13, 38, 45, 52], "mgpu": [4, 12, 18, 35, 37, 38, 39, 52, 70], "gpu_count": 4, "smi": [4, 61, 63], "l": [4, 20, 57, 65, 67], "wc": 4, "mpirun": [4, 38, 39, 52], "Not": [4, 24, 37, 63], "hybrid": [5, 17, 56, 64, 68], "involv": [5, 39, 52, 57, 67], "bloch": [5, 14], "ket": [5, 6, 7, 12, 14, 43, 55], "workflow": [5, 8, 17, 20, 47, 57, 61, 64], "intial": 5, "statevector": [5, 12, 52, 55, 68], "bra": [5, 7, 43], "cost_valu": [5, 9], "expectation_valu": [5, 48], "demonstr": [5, 6, 12, 15, 19, 20, 22, 38, 43, 46, 51, 57], "initial_cost_valu": 5, "suit": [5, 56, 63], "alogrithm": 5, "decreas": [5, 45], "x_valu": [5, 9], "y_valu": [5, 9], "epoch": [5, 8, 9, 15, 16], "text": [5, 6, 12, 13], "39": [5, 9, 13, 14, 16], "longrightarrow": 6, "balanc": 6, "regardless": [6, 67], "ouput": 6, "question": 6, "answer": [6, 12], "solv": [6, 7, 11, 12, 42], "treat": [6, 38], "snippet": [6, 37, 38, 48, 57, 63], "box": [6, 10, 67], "don": [6, 12, 18, 20, 37, 70], "access": [6, 12, 18, 20, 25, 36, 37, 46, 50, 51, 52, 55, 60, 70], "elif": 6, "That": [6, 20, 68], "twice": 6, "claim": 6, "evalul": 6, "advantag": [6, 63], "symbol": [6, 61, 67], "OR": [6, 49], "rule": 6, "modulo": 6, "oplus5": 6, "_": [6, 8, 13, 14, 45], "8_": 6, "oplus4": 6, "9_": 6, "quick": [6, 17, 36, 65], "suppos": [6, 64], "yield": [6, 55, 68], "sequenc": [6, 11, 34, 42], "u_f": 6, "align": [6, 12, 57, 67], "remark": 6, "becaus": [6, 13, 34, 39, 45, 49, 61, 63, 68], "overlin": 6, "bar": [6, 11, 12, 13, 14], "denot": [6, 12, 24, 26], "prove": [6, 55], "shall": [6, 7, 55], "tfrac": [6, 55], "summari": 6, "unchang": [6, 10, 57], "simultan": [6, 37], "mechan": [6, 20, 22, 28, 32, 34, 38, 44, 55, 59], "exploit": [6, 39], "abil": [6, 25, 46, 57], "neq": 6, "diagram": [6, 11, 12, 36, 49], "psi_0": 6, "tag": [6, 12, 61, 63], "psi_1": 6, "h_1h_0": 6, "frac": [6, 7, 11, 12, 13], "psi_2": 6, "drop": 6, "further": [6, 27, 34, 41, 43, 57, 60, 68], "psi_": 6, "pm": 6, "fx": 6, "shown": [6, 38, 39], "qubit_0": [6, 11], "quantiti": 7, "u_": 7, "qquad": 7, "x_1x_2": 7, "fact": [7, 12, 34, 67], "dagger": [7, 10, 29, 55], "simpl": [7, 10, 22, 25, 37, 38, 41, 43, 48, 49, 50, 53, 56, 57, 59, 63, 64, 68], "re": [7, 13, 20, 34, 50, 52, 53, 61, 63], "right": [7, 11, 12], "functool": [7, 13], "qubit_num": [7, 9, 16], "num": 7, "psi_stat": 7, "phi_stat": 7, "ham": [7, 9], "ham_matrix": 7, "exp_val": [7, 8, 15, 16, 38, 48], "dot": [7, 11, 13], "conj": 7, "707107": 7, "7071067690849304": 7, "u_psi": 7, "u_phi": 7, "ham_cir": 7, "mean_val": 7, "qc": [7, 36], "85356": 7, "14644": 7, "70712": 7, "0015811092713661505": 7, "mqpu": [7, 35, 39, 43, 48, 52], "qpu_count": [7, 38], "i_result": 7, "63807": 7, "36193": 7, "27614": 7, "0021491238917289066": 7, "49929": 7, "50071": 7, "00142": 7, "0022360657230949183": 7, "50041": 7, "49959": 7, "00082": 7, "0022360672257336093": 7, "50276": 7, "49724": 7, "00552": 7, "0022360339102974265": 7, "my_mat": 7, "dtype": [7, 10, 13, 53], "k": [7, 9, 12, 24, 56], "linalg": [7, 13], "eigh": 7, "eigen": [7, 23, 60], "00551752": 7, "27614248": 7, "00303004": 7, "99999541": 7, "highlight": [8, 18, 70], "pytorch": 8, "maximis": 8, "classif": 8, "mnist": 8, "dataset": 8, "classifi": 8, "hand": [8, 37, 38, 39, 63, 67], "written": [8, 13, 20, 55, 56, 61, 65], "digit": 8, "torch": 8, "torchvis": 8, "autograd": 8, "nn": 8, "sklearn": 8, "model_select": 8, "train_test_split": 8, "manual_se": 8, "22": [8, 13, 14, 43, 57, 61, 63], "44": [8, 13], "prepare_data": 8, "target_digit": 8, "sample_count": [8, 52], "test_siz": 8, "percentag": 8, "remaind": [8, 11], "train": 8, "totensor": 8, "1307": 8, "3081": 8, "download": [8, 14, 61, 63, 68], "filter": 8, "datapoint": 8, "subset_indic": 8, "randperm": 8, "unsqueez": 8, "relabel": 8, "min": [8, 49], "x_train": 8, "x_test": 8, "y_train": 8, "y_test": 8, "shuffl": 8, "random_st": 8, "classification_threshold": 8, "boundari": 8, "accuraci": [8, 39], "parmet": 8, "shift": [8, 37, 63], "magnitud": 8, "visualis": 8, "sample_to_plot": 8, "grid_img": 8, "make_grid": 8, "pad": 8, "imshow": 8, "permut": 8, "quantumfunct": 8, "finit": 8, "theta_v": 8, "excetut": 8, "live": 8, "tolist": 8, "shape": [8, 16, 52], "staticmethod": 8, "quantum_circuit": 8, "backward": [8, 26], "reshap": 8, "save_for_backward": 8, "grad_output": 8, "saved_tensor": 8, "thetas_plu": 8, "exp_vals_plu": 8, "thetas_minu": 8, "exp_vals_minu": 8, "mul": 8, "quantumlay": 8, "adher": [8, 24, 26, 32, 55, 60], "hybrid_qnn": 8, "fc1": 8, "fc2": 8, "dropout": 8, "fc3": 8, "fc4": 8, "fc5": 8, "feed": [8, 11], "view": [8, 25, 63, 69], "relu": 8, "fed": 8, "sigmoid": 8, "accuracy_scor": 8, "y_hat": 8, "hybrid_model": 8, "adadelta": 8, "lr": [8, 57], "001": [8, 12, 13, 63], "weight_decai": 8, "loss_funct": 8, "bceloss": 8, "training_cost": 8, "testing_cost": 8, "training_accuraci": 8, "testing_accuraci": 8, "zero_grad": 8, "y_hat_train": 8, "train_cost": 8, "eval": 8, "no_grad": 8, "y_hat_test": 8, "test_cost": 8, "figsiz": [8, 13], "subplot": [8, 13], "tight_layout": 8, "__version__": [8, 11, 12], "latest": [8, 11, 12, 18, 38, 61, 63, 70], "a726804916fd397408cbf595ce6fe5f33dcd8b4c": [8, 11, 12], "cliqu": 9, "non_edg": 9, "6686": 9, "1453": 9, "num_lay": 9, "expens": 9, "6886": 9, "1091": 9, "0770": 9, "ham_cliqu": 9, "spin_ham": [9, 16], "wt": 9, "zip": [9, 61], "term_coeffici": 9, "term_word": 9, "dc_qaoa": 9, "coef": 9, "pauli_word": [9, 38], "exp_pauli": 9, "iiziiz": 9, "ziizii": 9, "1657": 9, "iziiii": 9, "iziizi": 9, "42735": 9, "iiizii": 9, "2791499999999996": 9, "iiiiii": 9, "iiziii": 9, "iiiiiz": 9, "ziiiii": 9, "iiiizi": 9, "21810696323572243": [9, 11], "20613464375211488": [9, 11], "2546877639814583": [9, 11], "3657985647468064": [9, 11], "37118004688049144": 9, "03656087558321203": 9, "08564174998504231": 9, "21639801853794682": 9, "11122286088634259": 9, "1743727097033635": 9, "36518146001762486": 9, "15829741539542244": 9, "3467434780387345": 9, "28043500852894776": 9, "09986021299050934": 9, "14125225086023052": 9, "19141728018199775": 9, "11970943368650361": 9, "3853063093646483": 9, "1112643868789806": 9, "3527177454825464": 9, "22156160012057186": 9, "1418496891385843": 9, "32811766468303116": 9, "367642000671186": 9, "34158180583996006": 9, "10196745745501312": 9, "29359239180502594": 9, "3858537615546677": 9, "19366130907065582": 9, "24570488114056754": 9, "3332307385378807": 9, "12287973244618389": 9, "007274514934614895": 9, "015799547372526146": 9, "3578070967202224": 9, "39268963055535144": 9, "19872246354138554": 9, "16668715544467982": 9, "13777293592446055": 9, "17514665212709513": 9, "15350249947988204": 9, "32872977428061945": 9, "20068831419712105": 9, "032919322131134854": 9, "19399909325771983": 9, "09477141125241506": 9, "08210460401106645": 9, "21392577760158515": 9, "3393568044538389": 9, "14615087942938465": 9, "03790339186006314": 9, "2843250892879255": 9, "3151384847055956": 9, "19983741137121905": 9, "27348611567665115": 9, "33457528180906904": 9, "14145414847455462": 9, "20604220093940323": 9, "05410235084309195": 9, "04447870918600966": 9, "3355714098595045": 9, "266806440171265": 9, "07436189654442632": 9, "2789176729721685": 9, "2427508182662484": 9, "optimal_expect": [9, 11, 54], "0057970170760537": 9, "0617900450255213": 9, "008832997414504553": 9, "5446745231437978": 9, "9170743966952536": 9, "5684145055308018": 9, "45653992738579674": 9, "48765328828009236": 9, "08690545932812363": 9, "4396413285058074": 9, "18459993158979182": 9, "309747594917737": 9, "2588385005776594": 9, "834255663515425": 9, "674712608431175": 9, "40174553656823186": 9, "1936475123928361": 9, "11292461472367524": 9, "40520422214477836": 9, "5249647407525035": 9, "8276837818165452": 9, "2945660883282474": 9, "8060498989662159": 9, "08051672267342141": 9, "016438756265571293": 9, "5245041151262497": 9, "4087477995498743": 9, "24688680789607903": 9, "1121838066265077": 9, "1445970943333728": 9, "22281558391261153": 9, "29034932090910637": 9, "0492037973620043": 9, "2734013684834806": 9, "5265417924961102": 9, "5099056677967553": 9, "8636684922225737": 9, "6164906874232119": 9, "42851259141848624": 9, "09675272347583658": 9, "05697275350531247": 9, "7102412317670379": 9, "11174687408874051": 9, "32505750242276577": 9, "4397450017834574": 9, "023604090020531092": 9, "072436348972407": 9, "38357054930488194": 9, "13613334013073858": 9, "10505045798768743": 9, "0359359294549595": 9, "24377425227508304": 9, "10609870738840588": 9, "2073332743736556": 9, "07232539343493427": 9, "6190529241716675": 9, "03799182564866846": 9, "17548654124993912": 9, "5257077568577536": 9, "23376653076971432": 9, "3391308272563698": 9, "4193139961661264": 9, "02390444901420668": 9, "2521154835623746": 9, "1843328649807838": 9, "6609672889772077": 9, "2612231428844001": 9, "200000": 9, "mvwcp": 9, "altern": [9, 11, 36, 46, 49, 51, 54, 56, 61, 63, 68], "111000": 9, "character": [10, 13], "coher": [10, 24], "incoher": 10, "aris": 10, "commonli": [10, 61, 63], "systemat": 10, "miscalibr": 10, "epsilon": 10, "entangl": [10, 14, 25, 37, 41, 49, 56], "lead": [10, 11], "mix": [10, 49, 53], "emploi": 10, "formal": 10, "posit": [10, 11, 13, 27, 39], "preserv": 10, "k_i": 10, "satisfi": [10, 14, 32, 49, 61], "sum_": [10, 11, 12, 28, 55], "mathbb": [10, 11, 55], "pmatrix": 10, "ideal": [10, 37, 49], "noiseless": 10, "ideal_count": 10, "choos": [10, 43, 63], "error_prob": 10, "kraus_0": [10, 53], "complex128": [10, 53], "kraus_1": [10, 53], "bitflip_channel": 10, "0th": 10, "bitflip": [10, 13], "longer": [10, 46, 61], "uniformli": 10, "noisy_count": [10, 53], "850": 10, "88": 10, "56": 10, "noisy_result": [10, 53], "8666666666666666": 10, "farhi": 11, "et": 11, "al": 11, "introduc": [11, 20], "dive": [11, 14, 63], "ll": [11, 12, 50, 56, 57, 60, 64], "maxim": [11, 37, 39, 41, 49, 52], "although": [11, 55], "rel": [11, 39], "easi": [11, 53, 65], "vertic": [11, 14], "hard": 11, "wide": [11, 34, 57, 67], "statist": [11, 20, 23, 43, 55], "among": [11, 38], "furthermor": [11, 18, 70], "wider": [11, 38], "portfolio": 11, "shop": 11, "schedul": [11, 43], "vertex": 11, "subseteq": 11, "interchang": [11, 39], "undirect": 11, "v_0": 11, "v_1": 11, "exactli": 11, "bigcup": 11, "bigcap": 11, "emptyset": 11, "illustr": [11, 20, 36, 38, 47, 49, 50, 53, 54], "disjoint": 11, "grai": 11, "depict": [11, 14], "distinct": [11, 14, 34], "substack": 11, "sometim": 11, "01100": [11, 38], "01011": 11, "v1": [11, 36, 54], "v2": [11, 54], "v0": [11, 54], "v3": [11, 54, 61, 63], "v4": [11, 63], "solut": 11, "10100": 11, "01010": 11, "10101": 11, "edges_src": 11, "edges_tgt": 11, "algortihm": 11, "particular": [11, 14, 18, 36, 63, 67, 70], "hamilitonian": 11, "distinguish": [11, 34], "block": [11, 29, 56], "mixer": [11, 54], "deeper": [11, 14], "layer_count": [11, 54], "qaoaproblem": 11, "alpha": [11, 55], "subcircuit": [11, 42], "kernel_qaoa": [11, 54], "restrict": [11, 38], "plaehold": 11, "place": [11, 38, 41, 43, 45, 53], "compon": [11, 61, 63, 67, 68], "qubitu": 11, "qubitv": 11, "mention": 11, "earlier": [11, 43], "z_v": 11, "vale": 11, "arbirtrari": 11, "formula": 11, "z_uz_v": 11, "minimum": [11, 15, 37], "refram": 11, "promot": [11, 17, 68], "equat": [11, 12], "replac": [11, 36, 37, 56, 57, 59, 61, 63], "reformul": 11, "hamiltonian_max_cut": 11, "inititi": 11, "param": [11, 23, 24, 27, 37, 52, 54, 56], "comment": [11, 45], "iiziz": 11, "izzii": 11, "iiiii": 11, "zziii": 11, "iiizz": 11, "iizzi": 11, "ziizi": 11, "495973826282007": 11, "51349181993727": 11, "21299416361632417": 11, "3250526425808945": 11, "886630847343767": 11, "outcom": 11, "max_cut": 11, "11111": 11, "11110": 11, "01101": 11, "148": 11, "01110": 11, "47": [11, 13, 14], "01000": 11, "00110": 11, "54": [11, 13], "165": 11, "00101": 11, "154": 11, "00100": 11, "01001": 11, "41": [11, 14], "00000": 11, "00011": 11, "10011": [11, 38], "00010": 11, "01111": 11, "11011": 11, "00111": 11, "11100": 11, "10001": 11, "10010": 11, "144": [11, 13], "10110": 11, "40": [11, 13, 15, 52], "10000": [11, 36, 43, 49, 52], "10111": 11, "11000": 11, "11101": 11, "11001": 11, "11010": 11, "aid": [12, 19], "area": [12, 38], "signal": [12, 25], "compress": 12, "quantiz": 12, "qft": 12, "ingredi": 12, "shor": 12, "exponenti": [12, 13, 28, 52], "faster": [12, 39], "factor": [12, 13], "prime": 12, "plai": 12, "vital": 12, "role": 12, "interest": [12, 15, 16, 48, 50], "idea": 12, "frequenc": 12, "domain": 12, "easier": [12, 20, 57, 60], "analogi": 12, "ixi": 12, "rangl": [12, 13, 20, 68], "summar": [12, 63], "hadamard": [12, 17, 22, 27, 32, 34, 45, 50, 53, 55, 59], "5i": 12, "010": [12, 13], "35": [12, 13, 16], "0i": 12, "25i": 12, "35i": 12, "r_k": 12, "bmatrix": [12, 13, 55], "ciruit": 12, "quantum_fourier_transform": 12, "input_st": [12, 36, 49], "cr1": [12, 23], "zeroth": 12, "decim": 12, "round": [12, 23, 56], "r1": [12, 14, 23, 27, 34], "571": 12, "7854": 12, "25j": 12, "35j": 12, "verifi": [12, 55], "continu": [12, 43, 49, 57], "seri": [12, 36, 49], "henc": [12, 34, 38, 43, 52, 55, 61, 63, 67], "fast": [12, 25, 39, 42], "n2": 12, "why": 12, "life": [12, 37], "li": [12, 57], "One": [12, 20, 34, 38, 39, 44, 48], "invert": 12, "revers": [12, 31], "quantum_fourier_transform2": 12, "attent": 12, "definit": [12, 20, 22, 24, 53, 60], "unitari": [12, 15, 23, 27, 34, 51, 54, 55], "inverse_qft": 12, "verification_exampl": 12, "caus": 13, "imperfect": 13, "properli": [13, 43, 61, 67], "squar": [13, 32, 55], "tell": [13, 55], "independ": [13, 20, 25, 38, 39, 61], "estim": [13, 15, 43], "pseudoinvers": 13, "noisi": [13, 17, 47], "p_": 13, "adjust": [13, 39, 61, 67], "quasi": 13, "combin": [13, 17, 42, 43, 55, 66, 67], "correl": 13, "affect": [13, 39, 53, 60], "impract": 13, "seaborn": 13, "sn": 13, "itertool": 13, "union": 13, "set_styl": 13, "dark": 13, "prob": 13, "principl": 13, "yet": [13, 18, 38, 63, 70], "get_nois": 13, "n_qubit": [13, 23, 54, 56], "isinst": 13, "bit_flip": [13, 53], "help": [13, 14, 44, 63], "state_label": 13, "ghz": [13, 37, 38, 41, 43, 46, 49, 50, 52, 57, 64], "ghz_kernel": 13, "plot_cmat": 13, "mat": 13, "fig": 13, "ax": 13, "im2": 13, "matshow": 13, "cmap": 13, "cm": 13, "vmin": 13, "vmax": 13, "set_ytick": 13, "arang": 13, "set_xtick": 13, "set_yticklabel": 13, "set_xticklabel": 13, "set_titl": 13, "fontsiz": 13, "set_xlabel": 13, "xaxi": 13, "set_label_posit": 13, "set_ylabel": 13, "colorbar": 13, "closest": 13, "min_": 13, "rm": [13, 61, 63], "_1": 13, "find_closest_distribut": 13, "empirical_dist": 13, "empir": 13, "l1": 13, "ord": 13, "con": 13, "ineq": 13, "fun": [13, 16], "eq": [13, 57], "bnd": 13, "initial_valu": 13, "slsqp": 13, "maxit": [13, 15, 16], "get_counts_from_distribut": 13, "drawn": 13, "choic": [13, 39], "return_count": 13, "1024": [13, 46], "join": [13, 45], "noise_1": 13, "ghz_result": 13, "noisy_dict_1": 13, "dict": 13, "noisy_res_1": 13, "352": 13, "43": 13, "367": 13, "011": [13, 23], "61": 13, "110": 13, "low": [13, 27, 52], "noise_2": 13, "noisy_dict_2": 13, "noisy_res_2": 13, "149816047538945": 13, "3802857225639665": 13, "292797576724562": 13, "212": 13, "122": 13, "189": 13, "87": 13, "78": 13, "131": 13, "94": 13, "a_1": 13, "otim": 13, "single_qubit_label": 13, "single_qubit_st": 13, "924": 13, "104": 13, "920": 13, "true_stat": 13, "observed_st": 13, "90234375": 13, "1015625": 13, "09765625": 13, "8984375": 13, "joint": [13, 49], "a_pinv": 13, "pinv": 13, "positive_dist": 13, "ncorrect": [13, 23], "neg": [13, 27, 39], "476": 13, "501": [13, 20], "mitigated_sg": 13, "kind": [13, 43], "bar_label": 13, "assumpt": 13, "special": [13, 24, 29, 57, 65], "a_n": 13, "local_label": 13, "local_st": 13, "388": 13, "235": 13, "174": 13, "79": [13, 37], "58": 13, "23": 13, "38": [13, 61, 63], "370": 13, "60": [13, 63], "107": 13, "224": 13, "162": 13, "marginalized_count": 13, "total_shot": 13, "marginal_ct": 13, "85546875": 13, "15722656": 13, "14453125": 13, "84277344": 13, "6328125": 13, "38476562": 13, "3671875": 13, "61523438": 13, "70800781": 13, "32226562": 13, "29199219": 13, "67773438": 13, "pinv_confusion_matric": 13, "a_joint": 13, "559": 13, "26": [13, 14, 16, 37], "510": [13, 52], "521": 13, "446": 13, "mitigated_k_loc": 13, "accur": 13, "scale": [13, 27, 39, 52, 55], "248": 13, "159": 13, "83": 13, "68": 13, "161": 13, "93": 13, "46": 13, "363": 13, "253": 13, "76": 13, "378": 13, "150": [13, 55], "36": [13, 52, 56], "74": 13, "106": 13, "145": 13, "251": 13, "386": 13, "99": 13, "29": [13, 38], "229": 13, "247": 13, "70": 13, "163": 13, "371": 13, "95": 13, "157": 13, "233": 13, "85": [13, 52], "396": 13, "31": [13, 37, 52], "393": 13, "160": 13, "a_ful": 13, "24": [13, 14, 60, 64], "09734490298929": 13, "714": 13, "211": 13, "152": 13, "49": 13, "63": 13, "422": 13, "683": 13, "302": 13, "mitigated_ful": 13, "cue": 14, "sens": [14, 57], "evolut": [14, 23, 25, 34, 60], "mayb": 14, "dimension": [14, 32], "forc": [14, 15, 38, 67], "2d": 14, "cartesian": 14, "coordin": 14, "3d": 14, "sphere": 14, "showcas": 14, "render": 14, "qutip": 14, "sure": [14, 38, 61, 63, 65, 68], "restart": 14, "jupyt": [14, 63], "notebook": 14, "menu": 14, "vscode": [14, 63], "click": [14, 63], "button": 14, "toolbar": 14, "shell": [14, 61, 63, 68], "misunderstand": 14, "qualifi": 14, "bash": [14, 37, 61, 63, 68], "pipe": [14, 57], "sy": [14, 43, 68], "importerror": 14, "nnew": 14, "gt": 14, "post1": 14, "cp310": 14, "manylinux_2_17_x86_64": 14, "manylinux2014_x86_64": 14, "whl": [14, 61], "mb": 14, "eta": 14, "usr": [14, 57, 61, 63, 67], "lib": [14, 57, 59, 60, 61, 63, 64, 67, 68], "kiwisolv": 14, "contourpi": 14, "cycler": 14, "dateutil": 14, "post0": 14, "pillow": 14, "pypars": 14, "fonttool": 14, "six": 14, "successfulli": [14, 53], "root": [14, 61, 63], "broken": 14, "permiss": [14, 61, 63], "conflict": [14, 61], "behaviour": 14, "recommend": [14, 20, 61, 63, 68], "pypa": 14, "io": [14, 63], "venv": 14, "retri": 14, "subsequ": [14, 20, 25, 28, 30, 61, 63], "cell": 14, "instanti": [14, 20, 25, 31, 32, 37, 38, 54, 67], "add_to_bloch_spher": 14, "rng": 14, "default_rng": [14, 52], "blochspherelist": 14, "anglelist": 14, "sph": 14, "displai": [14, 19], "side": [14, 34, 63], "accordingli": [14, 39, 67], "space": [14, 17, 25, 32, 38, 49], "absolut": [14, 32, 57], "had": 14, "toolbox": 14, "blochspher": 14, "unfortun": 14, "handi": 14, "power": [14, 18, 37, 39, 52, 70], "kernel_to_draw": 14, "14159": 14, "tdg": [14, 27], "142": 14, "documentclass": 14, "usepackag": 14, "quantikz": 14, "lstick": 14, "q_0": 14, "amp": 14, "r_1": 14, "qw": 14, "q_1": 14, "targx": 14, "q_2": 14, "q_3": 14, "editor": 14, "export": [14, 36, 37, 38, 60, 61, 68], "molecular": [15, 17], "preprocess": 15, "h_2": 15, "molecul": [15, 17], "hartre": 15, "fock": 15, "uccsd": 15, "openfermionpyscf": [15, 16], "chain": [15, 34], "hydrogen": [15, 56], "atom": [15, 16, 55, 56], "seper": 15, "along": [15, 20, 36, 37, 39, 43, 67], "fix": [15, 18, 39, 70], "interv": 15, "bond": 15, "interatom": 15, "electrostat": 15, "electron": [15, 16], "proton": 15, "shield": 15, "neutron": 15, "chemic": 15, "minimis": 15, "stabl": [15, 63], "hydrogen_count": 15, "angstrom": 15, "bond_dist": 15, "7474": 15, "geometri": [15, 16], "chemistri": 15, "create_molecular_hamiltonian": 15, "sto": 15, "3g": 15, "electron_count": [15, 16], "n_electron": 15, "n_orbit": 15, "coupl": [15, 25, 39, 49, 63], "cluster": [15, 17, 38, 39], "uccsd_num_paramet": [15, 16], "builtin": [15, 57], "1371744305855906": 15, "popular": [15, 63], "callback": [15, 16], "xk": [15, 16], "x0": [15, 16, 20], "pyscf": 16, "openfermion": 16, "gto": 16, "scf": 16, "mcscf": 16, "cc": [16, 34, 57, 61], "1173": 16, "4691": 16, "7570": 16, "mol": 16, "charg": 16, "631g": 16, "myhf": 16, "rhf": 16, "max_cycl": 16, "nelec": 16, "nelectron": 16, "norb": 16, "mo_coeff": 16, "orbit": 16, "norb_ca": 16, "nele_ca": 16, "mycasci": 16, "casci": 16, "ncore": 16, "occupi": [16, 38], "frozen": 16, "mycc": 16, "e_tot": 16, "converg": 16, "9839755372789": 16, "98508980454675": 16, "e_corr": 16, "001114267267875617": 16, "jordan_wign": 16, "get_fermion_oper": 16, "timeit": [16, 43, 52], "run_pyscf": 16, "moleculardata": 16, "molecular_hamiltonian": 16, "get_molecular_hamiltonian": 16, "occupied_indic": 16, "active_indic": 16, "fermion_hamiltonian": 16, "qubit_hamiltonian": 16, "electron_num": 16, "start_tim": 16, "default_tim": 16, "300": 16, "end_tim": 16, "elaps": 16, "tmp": [16, 61], "ipykernel_23147": 16, "4290935201": 16, "complexwarn": 16, "discard": [16, 20], "98415928173183": 16, "105": 16, "929891359000067": 16, "welcom": [17, 37, 50, 63], "page": [17, 43, 48, 50, 61, 63, 68], "streamlin": [17, 68], "scalabl": [17, 37, 68], "offer": [17, 37, 68], "unifi": [17, 35, 68], "brows": 17, "amd64": [17, 18, 70], "pr": 17, "2023": 17, "releas": [17, 35, 38, 39, 57, 63, 68, 70], "toolchain": [17, 33, 36, 43, 57, 63, 64, 65, 66, 68], "heterogen": [17, 19, 42, 61], "troubleshoot": [17, 40], "introduct": [17, 33, 47, 65, 68], "synthesi": [17, 19, 22, 28, 32, 33, 47, 57], "bernstein": [17, 47, 63], "vazirani": [17, 47, 63], "eigensolv": [17, 47], "cuquantum": [17, 39, 47, 52, 60, 61], "deutsch": 17, "fourier": [17, 23], "qaoa": [17, 54], "neural": 17, "network": [17, 18, 36, 37, 38, 46, 49, 60, 63, 70], "dock": 17, "dc": 17, "readout": 17, "mitig": 17, "water": 17, "divis": 17, "With": [17, 18, 38, 43, 53, 57, 64, 70], "coreset": 17, "cloud": [17, 18, 35, 36, 49, 70], "processor": [17, 18, 20, 25, 35, 43, 63, 67, 68, 70], "center": [17, 62, 63], "integr": [17, 19, 25, 32, 36, 38, 63, 64], "downstream": [17, 60, 64, 66], "cmake": [17, 59, 60, 66], "ir": [17, 22, 44, 58, 59, 60], "repositori": [18, 59, 60, 61, 63, 70], "docker": [18, 61, 68, 70], "nightli": [18, 63, 70], "improv": [18, 39, 52, 63, 70], "eas": [18, 70], "think": [18, 38, 55, 70], "great": [18, 70], "contribut": [18, 63, 70], "thank": [18, 39, 70], "extern": [18, 39, 57, 59, 61, 67, 70], "contributor": [18, 70], "wheel": [18, 38, 39, 61, 70], "signific": [18, 70], "fusion": [18, 39, 70], "cudaq_mgpu_fus": [18, 39, 70], "bug": [18, 70], "greatli": [18, 70], "increas": [18, 39, 43, 52, 63, 68, 70], "frontend": [18, 70], "blog": [18, 70], "setup": [18, 39, 49, 63, 70], "scenario": [18, 51, 63, 70], "ve": [18, 50, 65, 70], "workload": [18, 38, 63, 70], "gnu": [18, 57, 61, 63, 67, 70], "guid": [18, 36, 61, 63, 65, 68, 70], "older": [18, 61, 63, 70], "glibc": [18, 61, 63, 70], "oqc": [18, 35, 70], "iqm": [18, 35, 70], "publish": [18, 63, 70], "experiment": [18, 63, 70], "arm": [18, 61, 63, 68, 70], "aarch64": [18, 68, 70], "pypi": [18, 61, 68, 70], "quantinuum": [18, 35, 70], "ionq": [18, 35, 70], "linux": [18, 57, 61, 63, 70], "concept": [19, 20, 24, 26], "bind": [19, 22, 24, 27, 61], "coprocess": 19, "annot": [19, 24, 41, 50], "aspect": [19, 20, 39, 67], "core": [19, 20, 39, 52, 57], "higher": 19, "namespac": [19, 20, 22, 23, 24, 27, 28, 30, 32, 33, 37, 38, 43, 48, 54, 59, 60, 65, 67], "philosophi": 20, "stand": 20, "alon": 20, "adaptor": 20, "post": [20, 36, 63], "returntyp": 20, "hasvoidreturntyp": 20, "is_void_v": 20, "sample_opt": 20, "bel": 20, "lu": [20, 23, 32, 46, 50, 51], "sequential_data": 20, "implicit": [20, 32, 34], "reg1": 20, "499": 20, "content": [20, 36, 49, 56, 60, 63], "appear": [20, 63], "alwai": [20, 39, 63], "middl": 20, "implicitli": [20, 25, 34], "ancilla": [20, 22], "difficult": 20, "discern": 20, "ones": 20, "silent": 20, "ancillari": [20, 45], "varieti": [20, 43], "enforc": 20, "sample_async_result": 20, "async_sample_result": [20, 38], "langl": 20, "\ud835\udeb9": 20, "observe_opt": 20, "retain": [20, 26], "measurecount": 20, "spinop": 20, "x0x1exp": 20, "x0x1data": 20, "qarrai": [20, 23, 24, 31, 50, 57], "907": [20, 23, 28, 37, 38, 48, 56], "1433": [20, 23, 28, 37, 38, 48, 56], "21829": [20, 23, 28, 37, 38, 48, 56], "lf": [20, 23, 38, 48], "analyt": 20, "async_observe_result": 20, "broader": [20, 38], "often": [20, 34, 61, 63], "extrem": 20, "dictat": 20, "safe": 20, "moreov": [20, 25, 38, 42, 60], "providesgradi": 20, "_providesgradi": 20, "someth": [20, 32, 61, 63, 67], "max_ev": [20, 56], "200": 20, "opt_energi": 20, "grad_vec": 20, "\ud835\udeb9_i": 20, "potenti": [20, 43], "variad": 20, "address": [20, 38, 61], "overal": [20, 57, 60], "deuteron_n3_ansatz": 20, "x1": 20, "vctrl": 20, "h3": 20, "625": 20, "913119": 20, "make_tupl": 20, "bfg": 20, "min_val": 20, "permit": 21, "facilit": [22, 63], "privat": [22, 32], "thenfunctor": 22, "predefin": 22, "otherkernelbuild": 22, "kerneltocal": 22, "kerneltocontrol": 22, "kerneltoadjoint": 22, "argsarrai": 22, "decltyp": 22, "tuple_s": 22, "integral_const": 22, "sizeof": [22, 65], "tuple_el": 22, "conditional_t": [22, 32], "factori": 22, "xprep": 22, "qubitin": 22, "hadamardtest": 22, "num_it": 23, "c_str": [23, 67], "phase_estim": 23, "cpp": [23, 36, 37, 38, 39, 43, 46, 48, 49, 50, 51, 53, 56, 57, 59, 60, 61, 63, 64, 65, 67, 68], "qpe": 23, "stdio": [23, 61], "cmath": 23, "iqft": 23, "denom": 23, "1ul": 23, "eigenst": 23, "stateprep": [23, 24], "ncountingqubit": 23, "state_prep": 23, "oracl": [23, 45], "counting_qubit": 23, "state_regist": 23, "put": [23, 32, 53, 55], "r1pigat": 23, "mostprob": 23, "to_integ": 23, "piestim": 23, "tgate": 23, "xgate": [23, 53], "nc": 23, "nq": 23, "countingqubit": 23, "stateregist": 23, "deuteron_n2_ansatz": 23, "param_spac": 23, "linspac": [23, 49], "energy_at_param": 23, "energyatparam": 23, "reflect_about_uniform": 23, "ctrlqubit": 23, "lastqubit": 23, "compute_act": [23, 29], "run_grov": 23, "callablekernel": 23, "n_iter": 23, "target_st": 23, "target_bit_set": 23, "secret": [23, 63], "strtol": 23, "null": [23, 63], "0b1011": 23, "compute_oracl": 23, "reflect": [23, 39], "iterative_qp": 23, "iqp": 23, "cr0": 23, "cr2": 23, "m_pi_4": 23, "differenti": 24, "former": 24, "latter": [24, 57], "my_first_entry_point_kernel": 24, "my_second_entry_point_kernel": 24, "my_first_pure_device_kernel": 24, "bodi": 24, "parent": 24, "stack": 24, "boolexprfromqubitmeasur": 24, "another_qubit": 24, "uncomput": [24, 25], "is_arithmetic_v": 24, "span": [24, 32], "recurs": 24, "mycustomsimplestruct": 24, "recursivevec": 24, "var": [24, 68], "kernelthatreturn": 24, "mysimplestruct": 24, "recursivelist": 24, "fill": [24, 49, 60], "1415926": 24, "kernellambda": 24, "synchron": [24, 38, 49], "mystateprep": 24, "prep": 24, "mygenericalgorithm": 24, "placehold": 24, "mygenericalgorithm2": 24, "callkernel": 24, "anothervers": 24, "constrain": [24, 51], "is_convertible_v": 24, "takes_qubit": [24, 51], "mygenericalgorithmonqarrai": 24, "mygenericalgorithmonqubit": 24, "presum": 25, "graphic": 25, "fpga": 25, "evolv": [25, 55], "concurr": [25, 37], "messag": [25, 37, 61, 63], "inter": [25, 39], "fabric": [25, 56], "drive": 25, "infinit": [25, 32, 43], "hidden": [25, 45], "purpos": [25, 34, 63], "novel": 25, "placement": 25, "copyabl": [25, 32], "flavor": 25, "tightli": 25, "modal": 25, "influenc": 25, "previou": [26, 32, 56, 63], "sfina": 26, "foundat": 27, "operand": [27, 38], "inst_nam": 27, "header": [27, 61, 63, 65, 67], "synthes": [27, 31, 57], "reli": [27, 57, 63, 65, 67], "qubitarg": 27, "qr": [27, 39], "scalarangl": 27, "rotation_nam": 27, "measure_op": 27, "convei": 27, "offici": [27, 61, 63], "p_i": 28, "prod_": 28, "sigma_j": 28, "th": 28, "trotter": 28, "intent": 29, "u_cod": 29, "v_code": 29, "computef": 29, "actionf": 29, "computel": 29, "segment": [29, 68], "effort": 30, "get_platform": [30, 38, 48], "ctrl_qubit": 31, "quantumregist": 31, "x_gate": 31, "toffoli": 31, "ctrl_bit": 31, "rx_and_h_gat": 31, "kerneltestcontrol": 31, "kerneltestadjoint": 31, "aggreg": 31, "qubit0": [31, 39], "qubit1": [31, 39], "kernel_arg": 31, "fundament": [32, 55, 63, 68], "hilbert": 32, "theorem": 32, "movabl": 32, "never": 32, "n_level": 32, "discret": 32, "adl": 32, "deal": 32, "familiar": 32, "inner": [32, 38, 45], "stride": 32, "first_5": 32, "qb": 32, "knowledg": 32, "ahead": 32, "storag": [32, 55], "fivecompiletimequbit": 32, "formul": 34, "short": 34, "particl": 34, "conceptu": 34, "effect": [34, 39, 43, 52, 53, 55, 68], "sai": 34, "embodi": 34, "greater": [34, 37, 39, 55], "behind": 34, "dataflow": 34, "contrast": 34, "consum": [34, 67], "truli": 34, "ssa": 34, "clarifi": 34, "toi": 34, "foo": 34, "boilerpl": [34, 60], "c0": 34, "c1": 34, "extract_ref": [34, 57], "ref": [34, 57], "bunch": 34, "decid": 34, "i1": [34, 57], "imagin": 34, "adjac": [34, 36], "naiv": 34, "awai": 34, "Such": [34, 43], "miss": [34, 39, 61], "Of": 34, "cours": 34, "correctli": [34, 61, 65, 67], "quit": [34, 43], "prone": 34, "analys": 34, "q0_1": 34, "q0_0": 34, "wire": 34, "q0_z": 34, "happen": [34, 63], "elimin": [34, 38], "r0": 34, "qref": 34, "unwrap": 34, "misc": 34, "q0_m": 34, "q0_l": 34, "q1_x": 34, "q0_p": 34, "q0_y": 34, "straightforwardli": 34, "cancel": [34, 53, 63, 68], "mmeori": 34, "comprehens": [35, 36], "orca": 35, "tensornet": [35, 37, 38, 39], "mp": [35, 37, 39], "account": [36, 37, 49, 63], "ionq_api_kei": 36, "ionq_generated_api_kei": 36, "authent": [36, 38, 63], "aria": [36, 49], "login": [36, 63], "emit": [36, 57], "diagnost": 36, "inject": [36, 49, 57, 63], "cortex": 36, "cli": [36, 63], "token": [36, 63], "cach": 36, "iqm_tokens_fil": 36, "mandatori": 36, "match": [36, 61, 63, 67], "coco": [36, 49], "adoni": [36, 49], "iqm_server_url": 36, "demo": 36, "fi": [36, 61], "apollo": 36, "url": [36, 38, 49, 61, 63], "oxford": 36, "ring": 36, "topologi": 36, "luci": 36, "kagom": 36, "lattic": 36, "toshiko": 36, "registr": [36, 59, 60], "contact": [36, 49], "oqc_qcaas_support": [36, 49], "oxfordquantumcircuit": [36, 49], "email": [36, 37], "password": [36, 63], "oqc_url": [36, 49], "oqc_email": [36, 49], "oqc_password": [36, 49], "suppli": 36, "qcaa": 36, "servic": [36, 37, 38, 49, 63], "assembli": 36, "qat": 36, "pt": [36, 49, 63], "boson": [36, 49], "photon": [36, 49, 55], "interf": [36, 49], "beam": [36, 49], "splitter": [36, 49], "detector": [36, 49], "bin": [36, 38, 49, 61, 63], "interferomet": [36, 49], "tbi": [36, 49], "delai": [36, 49], "sent": [36, 38, 49], "orca_access_url": [36, 49], "orca_url": [36, 49], "getenv": [36, 49], "localhost": [36, 38, 49, 63], "bs_angl": [36, 49], "loop_length": [36, 49], "apt": [36, 63], "curl": [36, 61], "jq": 36, "your_alia": 36, "your_password": 36, "qapi": 36, "home": [36, 37, 63], "id_token": 36, "cat": [36, 63], "refresh_token": 36, "refresh": 36, "echo": [36, 37, 61, 63, 67], "quantinuum_config": 36, "cudaq_quantinuum_credenti": 36, "checker": [36, 49], "mere": [36, 61], "h1": [36, 49], "2e": [36, 49], "sc": 36, "1sc": 36, "navig": [36, 63], "tab": [36, 63], "tabl": [36, 37, 38, 60, 63], "world": [37, 42, 50], "visit": [37, 43], "link": [37, 57, 61, 63, 64, 65, 67], "approv": 37, "nvqc_api_kei": 37, "session": [37, 38, 63], "bashrc": [37, 63], "rather": [37, 39, 43, 55, 67], "2024": 37, "438": 37, "3600": 37, "h100": 37, "80gb": 37, "hbm3": 37, "driver": [37, 61, 63], "gb": [37, 39, 52], "clock": 37, "rate": 37, "mhz": 37, "2619": 37, "1980": 37, "1111111111111111111111111": [37, 52], "486": 37, "0000000000000000000000000": [37, 52], "514": 37, "nvqc_intro": 37, "05": 37, "545": 37, "487": 37, "513": 37, "nvqc_sampl": 37, "grow": [37, 60], "beyond": [37, 39, 52, 59], "ngpu": 37, "unabl": [37, 63], "deploy": 37, "dm": 37, "ye": [37, 63], "cutensornet": [37, 39], "contract": [37, 39], "wherebi": [37, 38, 39], "worker": 37, "nqpu": 37, "opt_gradi": 37, "submiss": [37, 44, 49], "energy_futur": 37, "plus_futur": 37, "minus_futur": 37, "optimal_valu": 37, "grad": 37, "paramshift": 37, "74886": 37, "nvqc_vqe": 37, "incom": [37, 51], "attain": 37, "speedup": [37, 52], "On": [37, 38, 39, 46, 50, 63, 68], "busi": 37, "deliv": 37, "substanti": 37, "my": [37, 60, 63], "nvqc_log_level": 37, "disabl": [37, 39, 61], "credenti": [37, 49], "lieu": 37, "api_kei": 37, "nvqc_config": 37, "elucid": 38, "unlik": [38, 43], "opportun": 38, "count_futur": 38, "kerneltobesampl": 38, "runtimeparam": 38, "singleton": [38, 48], "zu": [38, 48], "countfutur": 38, "emplace_back": 38, "four": [38, 48, 55], "gpuemulatedqpu": 38, "37": 38, "33": [38, 63], "cudaq_mqpu_ngpu": 38, "bellow": 38, "state_futur": 38, "kerneltorun": 38, "async_state_result": 38, "statefutur": 38, "suffici": [38, 61, 63, 68], "mpiexec": [38, 39, 61], "script": [38, 43, 61, 63], "srun": 38, "controls_count": 38, "auto_launch": 38, "isdigit": 38, "nrcontrol": 38, "tidx": 38, "background": 38, "daemon": 38, "qpud": 38, "shut": 38, "manual": [38, 46, 53, 61, 63], "explain": [38, 55], "cudaq_loc": 38, "grep": [38, 61], "qpud_pi": 38, "cuda_visible_devic": [38, 39], "tcp": [38, 63], "ip": 38, "ld_library_path": [38, 61, 68], "launcher": 38, "app": 38, "firewal": 38, "secur": [38, 63], "port1": 38, "port2": 38, "port3": 38, "port4": 38, "per": [38, 39, 52, 56], "open": [38, 49, 57, 61, 63], "resolv": 38, "contigu": 38, "byte": [38, 52, 67], "memcpi": 38, "ixiz": 38, "charact": 38, "incur": 38, "overhead": 38, "0000": 38, "1111": 38, "demand": 38, "veri": [38, 50, 59, 67], "defer": 38, "rtti": 38, "standalon": [38, 60], "chosen": [39, 52, 61], "accommod": 39, "switch": [39, 52], "modif": [39, 43, 50], "invalid": 39, "cudaq_fusion_max_qubit": 39, "cudaq_fusion_diagonal_gate_max_qubit": 39, "diagon": 39, "cudaq_fusion_num_host_thread": 39, "cudaq_max_cpu_memory_gb": 39, "migrat": [39, 61], "unlimit": 39, "cudaq_max_gpu_memory_gb": 39, "exce": 39, "particularli": [39, 42], "cudaq_mgpu_lib_mpi": 39, "share": [39, 60, 63, 67], "libmpi": [39, 63], "cudaq_mgpu_comm_plugin_typ": 39, "openmpi": [39, 61, 63, 68], "mpich": [39, 61], "commplugin": 39, "cudaq_mgpu_nqubits_thresh": 39, "cudaq_mgpu_p2p_device_bit": 39, "gpudirect": 39, "p2p": 39, "cudaq_gpu_fabr": 39, "mnnvl": 39, "nvl": 39, "nvlink": 39, "cudaq_global_index_bit": 39, "comma": 39, "slower": 39, "cudaq_host_device_migration_level": 39, "tune": [39, 56], "fuse": 39, "4x4": 39, "bandwidth": 39, "significantli": 39, "suitabl": [39, 61, 63, 67], "despit": [39, 49], "poor": 39, "visibl": [39, 63], "cutensornet_comm_lib": 39, "newli": [39, 63], "libcutensornet_distributed_interface_mpi": 39, "dedic": 39, "dgx": 39, "omp_plac": 39, "omp_num_thread": 39, "number_of_cores_per_nod": 39, "number_of_gpus_per_nod": 39, "wave": 39, "sparsiti": 39, "decomposit": 39, "svd": 39, "singular": [39, 61], "truncat": 39, "tractabl": 39, "footprint": 39, "cudaq_mps_max_bond": 39, "cudaq_mps_abs_cutoff": 39, "cutoff": 39, "largest": 39, "trim": 39, "1e": 39, "cudaq_mps_relative_cutoff": 39, "fraction": 39, "cudaq_mps_svd_algo": 39, "gesvd": 39, "gesvdj": 39, "jacobi": 39, "gesvdp": 39, "gesvdr": 39, "medium": 39, "overridden": [39, 60], "cudaq_default_simul": [39, 46], "debug": [40, 57, 61, 63], "amongst": 41, "subroutin": 42, "closer": [42, 50, 57], "collaps": [43, 55, 60], "roughli": [43, 52, 53, 55], "50": [43, 53, 55, 67], "505": 43, "495": 43, "result_0": 43, "ensembl": 43, "5005": 43, "4995": 43, "result_1": 43, "subtl": 43, "repeatedli": 43, "rebuilt": 43, "most_probable_result": 43, "intens": 43, "respons": 43, "event": [43, 61], "kernel2": 43, "num_gpu": [43, 52], "result_2": 43, "confirm": [43, 49, 53, 61, 63, 68], "determinist": 43, "close": [43, 49], "025": 43, "million": 43, "35x": 43, "code_to_tim": 43, "1000000": 43, "57462": 43, "stmt": 43, "773286": 43, "isol": 43, "atoi": [43, 68], "chrono": 43, "high_resolution_clock": 43, "durat": 43, "took": 43, "8337": 43, "18988": 43, "cudaq_log_level": 44, "prepend": 44, "cudaq_dump_jit_ir": 44, "output_filenam": 44, "highest": 45, "random_bit": 45, "bitset": 45, "randint": 45, "un": 45, "difficulti": 45, "verif": 45, "hidden_bit": 45, "auxillary_qubit": 45, "bernstein_vazirani": [45, 63], "success": [45, 59], "random_bitstr": 45, "vector_of_bit": 45, "hidden_bitstr": 45, "recov": 45, "cuquantum_backend": 46, "hang": [46, 63, 68], "observe_mqpu": 48, "No": [49, 52, 63], "redefin": 49, "flight": 49, "async_count": 49, "txt": [49, 59, 60, 63, 64], "same_fil": 49, "retrieved_async_result": 49, "mimic": 49, "dashboard": 49, "fstream": 49, "meantim": [49, 63], "ofstream": 49, "savem": 49, "readin": 49, "ifstream": 49, "proceed": [49, 61], "qb1": 49, "qb2": 49, "qb3": 49, "qb4": 49, "qb5": 49, "adonis_ghz": 49, "transpar": 49, "worri": 49, "schemat": 49, "optic": 49, "reconfigur": 49, "shifter": 49, "enter": [49, 63], "indistinguish": 49, "vacuum": 49, "interfer": [49, 53, 61, 63], "exit": [49, 52, 63], "half": 49, "n_beam_splitt": 49, "ps_angl": 49, "n_sampl": 49, "helper": [49, 56], "linear_spaced_vector": 49, "static_cast": [49, 65], "sum_loop_length": 49, "accumul": 49, "n_loop": 49, "n_mode": 49, "endpoint": 49, "syntax_check": 49, "gotten": 50, "hello": [50, 63], "static_kernel": 50, "x_kernel": 51, "control_vector": 51, "multi_controlled_oper": 51, "ccnot": 51, "applyx": 51, "ccnot_test": 51, "apply_x": 51, "counts2": 51, "seamless": [52, 63], "multithread": 52, "ghz_state": 52, "sample_ghz_st": 52, "cpu_result": 52, "475": 52, "525": [52, 63], "2500x": 52, "gpu_result": 52, "490": 52, "8700": 52, "freeli": [52, 61, 63], "filenam": 52, "qubits_list": 52, "990": 52, "dev": [52, 61, 63], "xi": 52, "2500": 52, "4x": 52, "asyncresult": 52, "conclud": 53, "examin": 53, "scrambl": 53, "bring": 53, "noise_depolar": 53, "noiseless_count": 53, "environment": 53, "amplitude_damp": 53, "keyword": 53, "noiseless_result": 53, "noise_amplitude_damp": 53, "wherein": 53, "undergo": 53, "degre": 53, "noise_bit_flip": 53, "bf": 53, "phase_flip": 53, "presenc": 53, "noise_phase_flip": 53, "pf": 53, "kraus_oper": 53, "nielsen": 53, "chuang": 53, "chapter": 53, "depol": 53, "99498743710662": 53, "05773502691896258": 53, "unset": 53, "good": 53, "avoid": [53, 61, 67, 68], "rectangular": 54, "n_layer": [54, 56], "hp": 54, "random_vector": [54, 56], "mt19937": [54, 56], "default_se": [54, 56], "16lf": [54, 56], "transmiss": 55, "analog": 55, "counterpart": 55, "transistor": 55, "alter": 55, "superconduct": 55, "materi": 55, "ion": 55, "trap": 55, "concern": [55, 61], "ourselv": 55, "obei": 55, "law": 55, "mathemat": 55, "physicist": 55, "theori": 55, "linearli": 55, "logarithm": 55, "dirac": 55, "beta": [55, 57], "correspondingli": [55, 67], "approx": 55, "feasibl": 55, "art": [55, 67], "manipul": 55, "offload": 55, "equiv": 55, "lvert": 55, "rvert": 55, "502": 55, "498": 55, "modulu": 55, "conserv": 55, "uphold": 55, "excit": 55, "probabilist": 55, "infer": 55, "wavefunct": 55, "devis": 55, "phenomena": 55, "predict": 55, "postul": 55, "alpha_": 55, "propos": 56, "simple_vq": 56, "pick": [56, 60, 61], "nminim": 56, "vqe_h2": 56, "builder": [56, 57], "arrang": 56, "so4": 56, "so4_fabr": 56, "block_siz": 56, "counter": 56, "subq": 56, "so4_param": 56, "slice_vector": 56, "odd": 56, "h2_data": 56, "10647701149499994": 56, "0454063328691": 56, "170280101353": 56, "120200490713": 56, "168335986252": 56, "165606823582": 56, "22004130022499996": 56, "174072892497": 56, "17028010135300004": 56, "22004130022499999": 56, "p_counter": 56, "n_blocks_per_lay": 56, "init_param": 56, "max_line_search_tri": 56, "gradient_vector": 56, "adam": 56, "temp": 57, "llvm": [57, 59, 60, 61, 65], "qke": [57, 59], "pipelin": 57, "canonic": 57, "lift": 57, "indirect": 57, "direct": [57, 67], "loader": 57, "expand": 57, "cfg": 57, "cse": 57, "lpsxpu": 57, "p3de4l": 57, "fixup": 57, "linkag": 57, "pl": [57, 61], "llc": [57, 61], "reloc": 57, "pic": 57, "filetyp": 57, "obj": 57, "o2": 57, "clang": [57, 61, 67], "gcc": [57, 61, 63, 67], "x86_64": [57, 61, 63, 68], "lib64": [57, 63, 65], "stub": 57, "wl": [57, 61, 67], "rpath": [57, 67], "llib": 57, "lcudaq": 57, "ensmallen": 57, "em": 57, "lnvqir": 57, "orchestr": 57, "qtx": 57, "mangled_name_map": 57, "__nvqpp__mlirgen__ghz": 57, "_zn3ghzclei": 57, "i32": 57, "entrypoint": 57, "alloca": 57, "memref": 57, "extsi": 57, "c0_i32": 57, "c0_i32_0": 57, "alloca_1": 57, "c1_i32": 57, "subi": 57, "cmpi": 57, "slt": 57, "addi": 57, "unoptim": 57, "mangl": 57, "introspect": 57, "overwrit": 57, "libcudaq": 57, "libnvqir": [57, 60], "robust": 57, "intermedi": 57, "depart": 57, "recal": 57, "datalayout": 57, "p270": 57, "p271": 57, "p272": 57, "f80": 57, "n8": 57, "s128": 57, "unknown": [57, 63], "invokewithcontrolqubit": 57, "__quantum__qis__x__ctl": 57, "__quantum__rt__array_get_size_1d": 57, "__quantum__qis__h": 57, "i8": 57, "__quantum__rt__array_get_element_ptr_1d": 57, "sext": 57, "bitcast": 57, "icmp": 57, "sgt": 57, "br": 57, "ph": 57, "prehead": 57, "_crit_edg": 57, "pred": 57, "trip": 57, "zext": 57, "indvar": 57, "iv": 57, "nuw": 57, "nsw": 57, "nonnul": 57, "exitcond": 57, "ph3": 57, "_crit_edge4": 57, "exitcond5": 57, "mycustomplugin": 59, "cmakelist": [59, 60, 64], "add_llvm_pass_plugin": 59, "operationpass": 59, "quakedialect": 59, "quakeop": 59, "rewrit": 59, "frozenrewritepatternset": 59, "dialectconvers": 59, "replaceh": 59, "oprewritepattern": 59, "hop": 59, "logicalresult": 59, "matchandrewrit": 59, "patternrewrit": 59, "replaceopwithnewop": 59, "sop": 59, "isadj": 59, "getparamet": 59, "getcontrol": 59, "gettarget": 59, "custompassplugin": 59, "passwrapp": 59, "funcop": 59, "mlir_define_explicit_internal_inline_type_id": 59, "stringref": 59, "runonoper": 59, "getoper": 59, "getcontext": 59, "rewritepatternset": 59, "insert": 59, "conversiontarget": 59, "addlegaldialect": 59, "addillegalop": 59, "applypartialconvers": 59, "emitoperror": 59, "signalpassfailur": 59, "cudaq_register_mlir_pass": 59, "add_subdirectori": 59, "circuitsimulatorbas": 60, "lot": 60, "qppcircuitsimul": 60, "custateveccircuitsimul": 60, "openmp": [60, 61, 68], "addqubittost": 60, "addqubitstost": 60, "resetqubit": 60, "qubitidx": 60, "resetqubitstateimpl": 60, "applyg": 60, "gateapplicationtask": 60, "measurequbit": 60, "floattyp": 60, "mysimul": 60, "nvqir_register_simul": 60, "mysimulatorclassnam": 60, "dylib": 60, "nvqir_simulation_backend": 60, "cuda_quantum_path": [60, 61, 63, 64], "find_packag": [60, 64], "nvqir_add_backend": 60, "folder": [60, 61, 63, 64], "cmake_minimum_requir": [60, 64], "fatal_error": [60, 64], "democreatenvqirbackend": 60, "cxx": [60, 61, 64, 68], "measuredbit": 60, "cuda_quantum": [60, 61], "cd": [60, 61, 63, 64], "ninja": [60, 64], "dnvqir_dir": 60, "softwar": [61, 63], "rootless": 61, "admin": [61, 63], "meet": 61, "carefulli": 61, "almost": 61, "though": 61, "piec": 61, "requisit": 61, "almalinux": 61, "manylinux_2_28": 61, "cento": [61, 63], "debian": [61, 63], "fedora": [61, 63], "opensus": [61, 63], "sled": [61, 63], "sle": [61, 63], "rhel": [61, 63], "rocki": [61, 63], "ubuntu": [61, 63], "04": [61, 63], "newer": [61, 63, 68], "x86": [61, 63], "arm64": [61, 63, 68], "v8": [61, 63], "volta": [61, 63], "ture": [61, 63], "amper": [61, 63], "ada": [61, 63], "hopper": [61, 63], "470": [61, 63], "57": [61, 63], "02": [61, 63], "strongli": 61, "git": 61, "unzip": 61, "web": [61, 63], "cudaq_install_prefix": 61, "cuquantum_install_prefix": 61, "cutensor_install_prefix": 61, "cutensor": 61, "llvm_install_prefix": 61, "blas_install_prefix": 61, "bla": 61, "zlib_install_prefix": 61, "zlib": 61, "openssl_install_prefix": 61, "openssl": 61, "curl_install_prefix": 61, "protocol": 61, "deviat": 61, "toolkit": [61, 63, 65, 68], "onlin": [61, 63], "cuda_vers": [61, 63], "cuda_download_url": [61, 63], "repo": [61, 63], "subfold": [61, 63], "rhel8": [61, 63], "cuda_arch_fold": [61, 63], "dnf": [61, 63], "nobest": [61, 63], "setopt": [61, 63], "install_weak_dep": [61, 63], "tr": [61, 63], "gcc_version": 61, "toolset": [61, 67], "assembl": 61, "enable_script": 61, "gcc_toolchain": 61, "rh": 61, "cudacxx": 61, "nvcc": [61, 63, 65], "cudahostcxx": 61, "omit": 61, "commit": 61, "checkout": 61, "archiv": [61, 63, 67], "subsect": 61, "devel": [61, 63], "suffix": 61, "conda": [61, 68], "auditwheel": 61, "patchelf": 61, "llvm_project": 61, "flang": 61, "lld": 61, "install_prerequisit": [61, 63], "sh": [61, 63, 68], "fc": 61, "histori": 61, "setuptools_scm_pretend_vers": 61, "cudaq_wheel": 61, "manylinux_platform": 61, "linux_": 61, "sed": [61, 63], "manylinux_2_28_": 61, "pwd": [61, 67], "_skbuild": 61, "repair": 61, "plat": 61, "libcubla": [61, 63], "libcublaslt": 61, "libcusolv": [61, 63], "libcutensor": 61, "libcutensornet": 61, "libcustatevec": 61, "libcudart": 61, "libnvtoolsext": 61, "libnvidia": 61, "ml": 61, "wheelhous": 61, "inde": 61, "cudaq_enable_static_link": 61, "cudaq_require_openmp": 61, "cudaq_werror": 61, "cudaq_python_support": 61, "build_cudaq": 61, "primarili": 61, "linker": [61, 67], "makeself": 61, "cuda_quantum_asset": 61, "mv": 61, "ld": 61, "build_config": 61, "xml": 61, "gzip": [61, 63], "sha256": 61, "install_cuda_quantum": [61, 63, 68], "unam": [61, 63, 68], "migrate_asset": 61, "search": [61, 63], "libc6": [61, 63], "sudo": [61, 63, 68], "set_env": [61, 63], "asset": [61, 63, 68], "highli": [61, 63], "profil": [61, 63, 68], "Their": 61, "did": [61, 63], "prefer": [61, 63], "version_suffix": [61, 63], "nvtx": [61, 63], "cudart": [61, 63], "awar": 61, "autoconf": 61, "libtool": 61, "flex": 61, "openmpi_vers": 61, "openmpi_download_url": 61, "ompi": 61, "tar": [61, 63], "gz": [61, 63], "xf": 61, "strip": 61, "rf": [61, 63], "autogen": 61, "ldflag": 61, "prefix": [61, 63], "getpwuid": 61, "mem": 61, "memcheck": 61, "verb": 61, "nproc": 61, "mpic": 61, "mpi_cuda_check": 61, "__has_includ": 61, "ext": 61, "endif": 61, "mpi_init": 61, "exit_cod": 61, "mpix_query_cuda_support": 61, "mpi_fin": 61, "mca": 61, "plm_rsh_agent": 61, "ssh": 61, "agent": 61, "rsh": 61, "unless": [61, 63], "slurm": 61, "mpi_path": [61, 63, 68], "distributed_interfac": [61, 63, 68], "activate_custom_mpi": [61, 63, 68], "guidanc": 63, "bundl": 63, "deploi": 63, "unsur": 63, "engin": 63, "desktop": 63, "administr": 63, "ngc": 63, "whenev": 63, "pull": 63, "nvcr": 63, "prototyp": 63, "tri": 63, "readm": 63, "appreci": 63, "insuffici": 63, "hover": 63, "rsa": 63, "id_rsa": 63, "pub": 63, "itd": 63, "2222": 63, "exec": 63, "openssh": 63, "usepam": 63, "sshd_config": 63, "cp": 63, "authorized_kei": 63, "sbin": 63, "sshd": 63, "stricthostkeycheck": 63, "userknownhostsfil": 63, "globalknownhostsfil": 63, "relocat": 63, "wsl": 63, "prerequisit": 63, "sylab": 63, "ce": 63, "xzf": 63, "mconfig": 63, "suid": 63, "builddir": 63, "bootstrap": 63, "runscript": 63, "mount": 63, "devpt": 63, "fakeroot": 63, "sif": 63, "writabl": 63, "nv": 63, "conf": 63, "ldd": [63, 67], "privileg": 63, "revis": 63, "upvot": 63, "posix": 63, "browser": 63, "palett": 63, "attach": 63, "window": 63, "reload": 63, "microsoft": 63, "sandbox": 63, "portmap": 63, "sshd_output": 63, "listen": 63, "1025": 63, "65535": 63, "ui": 63, "encrypt": 63, "pop": [63, 67], "ask": 63, "aren": 63, "icon": 63, "sidebar": 63, "prompt": 63, "workspac": 63, "edit": 63, "remotecommand": 63, "requesttti": 63, "hostnam": 63, "enableremotecommand": 63, "uselocalserv": 63, "remoteserverlistenonsocket": 63, "connecttimeout": 63, "serverinstallpath": 63, "sign": 63, "upgrad": 63, "ac": 63, "ace_nam": 63, "instance_nam": 63, "commandlin": 63, "job_id": 63, "600": 63, "8888": 63, "lab": 63, "portal": 63, "minut": 63, "404": 63, "patient": 63, "happi": 63, "cuda11x": 63, "ship": 63, "vendor": 63, "prebuilt": 63, "guarante": 63, "libcudaq_distributed_interface_mpi": 63, "cudaq_mpi_comm_lib": 63, "uninstal": 63, "dsize": 63, "fairli": 63, "succe": 63, "proce": [63, 68], "sort": 64, "imper": 64, "mycudaqapp": 64, "add_execut": 64, "ghz_ex": 64, "dcudaq_dir": 64, "cu": 65, "my_proj": 65, "conform": 65, "my_proj_quantum": 65, "libc": 65, "cudadatatyp": [65, 67], "cudasetfirstnel": 65, "sv": 65, "__restrict__": 65, "sv2": 65, "int64_t": 65, "blockidx": 65, "blockdim": 65, "threadidx": 65, "setfirstnel": 65, "uint32_t": [65, 67], "n_block": [65, 67], "int32_t": [65, 67], "threads_per_block": [65, 67], "newdevicestatevector": 65, "devicestatevector": [65, 67], "previousstatedimens": 65, "reinterpret_cast": [65, 67], "cufloatcomplex": [65, 67], "cudoublecomplex": [65, 67], "cucomplex": 65, "cuda_runtim": 65, "device_launch_paramet": 65, "my_kernel": 65, "cudamalloc": 65, "xcompil": 65, "fpic": [65, 67], "cuda_hom": 65, "lcudart": 65, "my_execut": 65, "outlin": 67, "hood": 67, "quantum_kernel": 67, "sstream": 67, "chanc": 67, "bell_distribut": 67, "stringbuf": 67, "ptr": 67, "strcpy": 67, "libstdc": 67, "libquantum_kernel": 67, "bell_dist": 67, "endl": 67, "lquantum_kernel": 67, "abi": 67, "incompat": 67, "watch": 67, "surround": 67, "wherea": 67, "third_party_librari": 67, "libexternal_librari": 67, "my_cod": 67, "bstatic": 67, "lexternal_librari": 67, "bdynam": 67, "undefin": 67, "crut": 67, "libexternal_library_complet": 67, "naddlib": 67, "nsave": 67, "nend": 67, "lexternal_library_complet": 67, "shim": 67, "pragma": 67, "is_integr": 67, "initializedevicestatevector": 67, "statedimens": 67, "cudainitializedevicestatevector": 67, "cumbersom": 67, "necessarili": 67, "recogn": 67, "catch": 67, "forg": 68, "env": 68, "conda_prefix": 68, "ompi_mca_opal_cuda_support": 68, "ompi_mca_btl": 68, "openib": 68, "fault": 68, "bash_profil": 68, "bash_login": 68, "intel": 68, "amd": 68, "averag": 68}, "objects": {"": [[2, 0, 1, "_CPPv45cudaq", "cudaq"], [2, 1, 1, "_CPPv4N5cudaq20BaseNvcfSimulatorQPUE", "cudaq::BaseNvcfSimulatorQPU"], [2, 1, 1, "_CPPv4N5cudaq17BaseRemoteRESTQPUE", "cudaq::BaseRemoteRESTQPU"], [2, 1, 1, "_CPPv4N5cudaq22BaseRemoteSimulatorQPUE", "cudaq::BaseRemoteSimulatorQPU"], [2, 1, 1, "_CPPv4I0EN5cudaq9CusvStateE", "cudaq::CusvState"], [2, 2, 1, "_CPPv4I0EN5cudaq9CusvStateE", "cudaq::CusvState::ScalarType"], [2, 1, 1, "_CPPv4N5cudaq16ExecutionContextE", "cudaq::ExecutionContext"], [2, 3, 1, "_CPPv4N5cudaq16ExecutionContext16ExecutionContextEKNSt6stringE", "cudaq::ExecutionContext::ExecutionContext"], [2, 3, 1, "_CPPv4N5cudaq16ExecutionContext16ExecutionContextEKNSt6stringENSt6size_tE", "cudaq::ExecutionContext::ExecutionContext"], [2, 4, 1, "_CPPv4N5cudaq16ExecutionContext16ExecutionContextEKNSt6stringE", "cudaq::ExecutionContext::ExecutionContext::n"], [2, 4, 1, "_CPPv4N5cudaq16ExecutionContext16ExecutionContextEKNSt6stringENSt6size_tE", "cudaq::ExecutionContext::ExecutionContext::n"], [2, 4, 1, "_CPPv4N5cudaq16ExecutionContext16ExecutionContextEKNSt6stringENSt6size_tE", "cudaq::ExecutionContext::ExecutionContext::shots_"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext13amplitudeMapsE", "cudaq::ExecutionContext::amplitudeMaps"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext9asyncExecE", "cudaq::ExecutionContext::asyncExec"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext14batchIterationE", "cudaq::ExecutionContext::batchIteration"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext16canHandleObserveE", "cudaq::ExecutionContext::canHandleObserve"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext16expectationValueE", "cudaq::ExecutionContext::expectationValue"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext12futureResultE", "cudaq::ExecutionContext::futureResult"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext31hasConditionalsOnMeasureResultsE", "cudaq::ExecutionContext::hasConditionalsOnMeasureResults"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext22invocationResultBufferE", "cudaq::ExecutionContext::invocationResultBuffer"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext10kernelNameE", "cudaq::ExecutionContext::kernelName"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext11kernelTraceE", "cudaq::ExecutionContext::kernelTrace"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext4nameE", "cudaq::ExecutionContext::name"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext10noiseModelE", "cudaq::ExecutionContext::noiseModel"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext9optResultE", "cudaq::ExecutionContext::optResult"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext20overlapComputeStatesE", "cudaq::ExecutionContext::overlapComputeStates"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext13overlapResultE", "cudaq::ExecutionContext::overlapResult"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext13registerNamesE", "cudaq::ExecutionContext::registerNames"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext10reorderIdxE", "cudaq::ExecutionContext::reorderIdx"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext6resultE", "cudaq::ExecutionContext::result"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext5shotsE", "cudaq::ExecutionContext::shots"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext15simulationStateE", "cudaq::ExecutionContext::simulationState"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext4spinE", "cudaq::ExecutionContext::spin"], [2, 5, 1, "_CPPv4N5cudaq16ExecutionContext15totalIterationsE", "cudaq::ExecutionContext::totalIterations"], [2, 1, 1, "_CPPv4N5cudaq15ExecutionResultE", "cudaq::ExecutionResult"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionary", "cudaq::ExecutionResult::ExecutionResult"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryNSt6stringE", "cudaq::ExecutionResult::ExecutionResult"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryd", "cudaq::ExecutionResult::ExecutionResult"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultENSt6stringE", "cudaq::ExecutionResult::ExecutionResult"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultERK15ExecutionResult", "cudaq::ExecutionResult::ExecutionResult"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultEd", "cudaq::ExecutionResult::ExecutionResult"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultEv", "cudaq::ExecutionResult::ExecutionResult"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionary", "cudaq::ExecutionResult::ExecutionResult::c"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryNSt6stringE", "cudaq::ExecutionResult::ExecutionResult::c"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryd", "cudaq::ExecutionResult::ExecutionResult::c"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryd", "cudaq::ExecutionResult::ExecutionResult::e"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultEd", "cudaq::ExecutionResult::ExecutionResult::expVal"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryNSt6stringE", "cudaq::ExecutionResult::ExecutionResult::name"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultENSt6stringE", "cudaq::ExecutionResult::ExecutionResult::name"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultERK15ExecutionResult", "cudaq::ExecutionResult::ExecutionResult::other"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult12appendResultENSt6stringENSt6size_tE", "cudaq::ExecutionResult::appendResult"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult12appendResultENSt6stringENSt6size_tE", "cudaq::ExecutionResult::appendResult::bitString"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult12appendResultENSt6stringENSt6size_tE", "cudaq::ExecutionResult::appendResult::count"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResult11deserializeERNSt6vectorINSt6size_tEEE", "cudaq::ExecutionResult::deserialize"], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResult11deserializeERNSt6vectorINSt6size_tEEE", "cudaq::ExecutionResult::deserialize::data"], [2, 3, 1, "_CPPv4N5cudaq15ExecutionResultaSERK15ExecutionResult", "cudaq::ExecutionResult::operator="], [2, 4, 1, "_CPPv4N5cudaq15ExecutionResultaSERK15ExecutionResult", "cudaq::ExecutionResult::operator=::other"], [2, 3, 1, "_CPPv4NK5cudaq15ExecutionResulteqERK15ExecutionResult", "cudaq::ExecutionResult::operator=="], [2, 4, 1, "_CPPv4NK5cudaq15ExecutionResulteqERK15ExecutionResult", "cudaq::ExecutionResult::operator==::result"], [2, 5, 1, "_CPPv4N5cudaq15ExecutionResult12registerNameE", "cudaq::ExecutionResult::registerName"], [2, 5, 1, "_CPPv4N5cudaq15ExecutionResult14sequentialDataE", "cudaq::ExecutionResult::sequentialData"], [2, 3, 1, "_CPPv4NK5cudaq15ExecutionResult9serializeEv", "cudaq::ExecutionResult::serialize"], [2, 0, 1, "_CPPv4N5cudaq19KernelExecutionTaskE", "cudaq::KernelExecutionTask"], [2, 1, 1, "_CPPv4N5cudaq3QPUE", "cudaq::QPU"], [2, 3, 1, "_CPPv4N5cudaq3QPU3QPUENSt6size_tE", "cudaq::QPU::QPU"], [2, 3, 1, "_CPPv4N5cudaq3QPU3QPUERR3QPU", "cudaq::QPU::QPU"], [2, 3, 1, "_CPPv4N5cudaq3QPU3QPUEv", "cudaq::QPU::QPU"], [2, 4, 1, "_CPPv4N5cudaq3QPU3QPUENSt6size_tE", "cudaq::QPU::QPU::_qpuId"], [2, 3, 1, "_CPPv4N5cudaq3QPU7enqueueER11QuantumTask", "cudaq::QPU::enqueue"], [2, 4, 1, "_CPPv4N5cudaq3QPU7enqueueER11QuantumTask", "cudaq::QPU::enqueue::task"], [2, 3, 1, "_CPPv4N5cudaq3QPU15getConnectivityEv", "cudaq::QPU::getConnectivity"], [2, 3, 1, "_CPPv4NK5cudaq3QPU20getExecutionThreadIdEv", "cudaq::QPU::getExecutionThreadId"], [2, 3, 1, "_CPPv4N5cudaq3QPU12getNumQubitsEv", "cudaq::QPU::getNumQubits"], [2, 3, 1, "_CPPv4NK5cudaq3QPU21getRemoteCapabilitiesEv", "cudaq::QPU::getRemoteCapabilities"], [2, 3, 1, "_CPPv4N5cudaq3QPU10isEmulatedEv", "cudaq::QPU::isEmulated"], [2, 3, 1, "_CPPv4N5cudaq3QPU11isSimulatorEv", "cudaq::QPU::isSimulator"], [2, 3, 1, "_CPPv4N5cudaq3QPU12launchKernelERKNSt6stringEPFvPvEPvNSt8uint64_tENSt8uint64_tE", "cudaq::QPU::launchKernel"], [2, 4, 1, "_CPPv4N5cudaq3QPU12launchKernelERKNSt6stringEPFvPvEPvNSt8uint64_tENSt8uint64_tE", "cudaq::QPU::launchKernel::args"], [2, 4, 1, "_CPPv4N5cudaq3QPU12launchKernelERKNSt6stringEPFvPvEPvNSt8uint64_tENSt8uint64_tE", "cudaq::QPU::launchKernel::kernelFunc"], [2, 4, 1, "_CPPv4N5cudaq3QPU12launchKernelERKNSt6stringEPFvPvEPvNSt8uint64_tENSt8uint64_tE", "cudaq::QPU::launchKernel::name"], [2, 3, 1, "_CPPv4N5cudaq3QPU29launchSerializedCodeExecutionERKNSt6stringERN5cudaq30SerializedCodeExecutionContextE", "cudaq::QPU::launchSerializedCodeExecution"], [2, 4, 1, "_CPPv4N5cudaq3QPU29launchSerializedCodeExecutionERKNSt6stringERN5cudaq30SerializedCodeExecutionContextE", "cudaq::QPU::launchSerializedCodeExecution::name"], [2, 4, 1, "_CPPv4N5cudaq3QPU29launchSerializedCodeExecutionERKNSt6stringERN5cudaq30SerializedCodeExecutionContextE", "cudaq::QPU::launchSerializedCodeExecution::serializeCodeExecutionObject"], [2, 3, 1, "_CPPv4N5cudaq3QPU15onRandomSeedSetENSt6size_tE", "cudaq::QPU::onRandomSeedSet"], [2, 4, 1, "_CPPv4N5cudaq3QPU15onRandomSeedSetENSt6size_tE", "cudaq::QPU::onRandomSeedSet::seed"], [2, 3, 1, "_CPPv4N5cudaq3QPU21resetExecutionContextEv", "cudaq::QPU::resetExecutionContext"], [2, 3, 1, "_CPPv4N5cudaq3QPU19setExecutionContextEP16ExecutionContext", "cudaq::QPU::setExecutionContext"], [2, 4, 1, "_CPPv4N5cudaq3QPU19setExecutionContextEP16ExecutionContext", "cudaq::QPU::setExecutionContext::context"], [2, 3, 1, "_CPPv4N5cudaq3QPU5setIdENSt6size_tE", "cudaq::QPU::setId"], [2, 4, 1, "_CPPv4N5cudaq3QPU5setIdENSt6size_tE", "cudaq::QPU::setId::_qpuId"], [2, 3, 1, "_CPPv4N5cudaq3QPU8setShotsEi", "cudaq::QPU::setShots"], [2, 4, 1, "_CPPv4N5cudaq3QPU8setShotsEi", "cudaq::QPU::setShots::_nShots"], [2, 3, 1, "_CPPv4N5cudaq3QPU27supportsConditionalFeedbackEv", "cudaq::QPU::supportsConditionalFeedback"], [2, 3, 1, "_CPPv4N5cudaq3QPUD0Ev", "cudaq::QPU::~QPU"], [2, 1, 1, "_CPPv4N5cudaq10QuakeValueE", "cudaq::QuakeValue"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEN4mlir5ValueE", "cudaq::QuakeValue::QuakeValue"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEd", "cudaq::QuakeValue::QuakeValue"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEN4mlir5ValueE", "cudaq::QuakeValue::QuakeValue::builder"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEd", "cudaq::QuakeValue::QuakeValue::builder"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEN4mlir5ValueE", "cudaq::QuakeValue::QuakeValue::v"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEd", "cudaq::QuakeValue::QuakeValue::v"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue22canValidateNumElementsEv", "cudaq::QuakeValue::canValidateNumElements"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue12constantSizeEv", "cudaq::QuakeValue::constantSize"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue4dumpERNSt7ostreamE", "cudaq::QuakeValue::dump"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue4dumpEv", "cudaq::QuakeValue::dump"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue19getRequiredElementsEv", "cudaq::QuakeValue::getRequiredElements"], [2, 3, 1, "_CPPv4NK5cudaq10QuakeValue8getValueEv", "cudaq::QuakeValue::getValue"], [2, 3, 1, "_CPPv4NK5cudaq10QuakeValue7inverseEv", "cudaq::QuakeValue::inverse"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue8isStdVecEv", "cudaq::QuakeValue::isStdVec"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValuemlE10QuakeValue", "cudaq::QuakeValue::operator*"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValuemlEKd", "cudaq::QuakeValue::operator*"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValuemlE10QuakeValue", "cudaq::QuakeValue::operator*::other"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValueplE10QuakeValue", "cudaq::QuakeValue::operator+"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValueplEKd", "cudaq::QuakeValue::operator+"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValueplEKi", "cudaq::QuakeValue::operator+"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValueplE10QuakeValue", "cudaq::QuakeValue::operator+::other"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValuemiE10QuakeValue", "cudaq::QuakeValue::operator-"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValuemiEKd", "cudaq::QuakeValue::operator-"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValuemiEKi", "cudaq::QuakeValue::operator-"], [2, 3, 1, "_CPPv4NK5cudaq10QuakeValuemiEv", "cudaq::QuakeValue::operator-"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValuemiE10QuakeValue", "cudaq::QuakeValue::operator-::other"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValuedvE10QuakeValue", "cudaq::QuakeValue::operator/"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValuedvEKd", "cudaq::QuakeValue::operator/"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValuedvE10QuakeValue", "cudaq::QuakeValue::operator/::other"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValueixEKNSt6size_tE", "cudaq::QuakeValue::operator[]"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValueixERK10QuakeValue", "cudaq::QuakeValue::operator[]"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValueixEKNSt6size_tE", "cudaq::QuakeValue::operator[]::idx"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValueixERK10QuakeValue", "cudaq::QuakeValue::operator[]::idx"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue4sizeEv", "cudaq::QuakeValue::size"], [2, 3, 1, "_CPPv4N5cudaq10QuakeValue5sliceEKNSt6size_tEKNSt6size_tE", "cudaq::QuakeValue::slice"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValue5sliceEKNSt6size_tEKNSt6size_tE", "cudaq::QuakeValue::slice::count"], [2, 4, 1, "_CPPv4N5cudaq10QuakeValue5sliceEKNSt6size_tEKNSt6size_tE", "cudaq::QuakeValue::slice::startIdx"], [2, 0, 1, "_CPPv4N5cudaq11QuantumTaskE", "cudaq::QuantumTask"], [2, 0, 1, "_CPPv4N5cudaq17QubitConnectivityE", "cudaq::QubitConnectivity"], [2, 0, 1, "_CPPv4N5cudaq9QubitEdgeE", "cudaq::QubitEdge"], [2, 1, 1, "_CPPv4N5cudaq18RemoteCapabilitiesE", "cudaq::RemoteCapabilities"], [2, 3, 1, "_CPPv4N5cudaq18RemoteCapabilities18RemoteCapabilitiesEb", "cudaq::RemoteCapabilities::RemoteCapabilities"], [2, 4, 1, "_CPPv4N5cudaq18RemoteCapabilities18RemoteCapabilitiesEb", "cudaq::RemoteCapabilities::RemoteCapabilities::initValue"], [2, 5, 1, "_CPPv4N5cudaq18RemoteCapabilities18serializedCodeExecE", "cudaq::RemoteCapabilities::serializedCodeExec"], [2, 5, 1, "_CPPv4N5cudaq18RemoteCapabilities12stateOverlapE", "cudaq::RemoteCapabilities::stateOverlap"], [2, 5, 1, "_CPPv4N5cudaq18RemoteCapabilities3vqeE", "cudaq::RemoteCapabilities::vqe"], [2, 1, 1, "_CPPv4N5cudaq21RemoteSimulationStateE", "cudaq::RemoteSimulationState"], [2, 1, 1, "_CPPv4N5cudaq9ResourcesE", "cudaq::Resources"], [2, 1, 1, "_CPPv4N5cudaq30SerializedCodeExecutionContextE", "cudaq::SerializedCodeExecutionContext"], [2, 1, 1, "_CPPv4N5cudaq15SimulationStateE", "cudaq::SimulationState"], [2, 1, 1, "_CPPv4N5cudaq15SimulationState6TensorE", "cudaq::SimulationState::Tensor"], [2, 6, 1, "_CPPv4N5cudaq15SimulationState9precisionE", "cudaq::SimulationState::precision"], [2, 7, 1, "_CPPv4N5cudaq15SimulationState9precision4fp32E", "cudaq::SimulationState::precision::fp32"], [2, 7, 1, "_CPPv4N5cudaq15SimulationState9precision4fp64E", "cudaq::SimulationState::precision::fp64"], [2, 0, 1, "_CPPv4N5cudaq15TensorStateDataE", "cudaq::TensorStateData"], [2, 1, 1, "_CPPv4N5cudaq5TraceE", "cudaq::Trace"], [2, 1, 1, "_CPPv4N5cudaq25amplitude_damping_channelE", "cudaq::amplitude_damping_channel"], [2, 1, 1, "_CPPv4I0EN5cudaq12async_resultE", "cudaq::async_result"], [2, 2, 1, "_CPPv4I0EN5cudaq12async_resultE", "cudaq::async_result::T"], [2, 3, 1, "_CPPv4N5cudaq12async_result3getEv", "cudaq::async_result::get"], [2, 1, 1, "_CPPv4N5cudaq16bit_flip_channelE", "cudaq::bit_flip_channel"], [2, 0, 1, "_CPPv4N5cudaq7complexE", "cudaq::complex"], [2, 1, 1, "_CPPv4N5cudaq14complex_matrixE", "cudaq::complex_matrix"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrix4colsEv", "cudaq::complex_matrix::cols"], [2, 3, 1, "_CPPv4N5cudaq14complex_matrix14complex_matrixEKNSt6size_tEKNSt6size_tE", "cudaq::complex_matrix::complex_matrix"], [2, 3, 1, "_CPPv4N5cudaq14complex_matrix14complex_matrixEP10value_typeKNSt6size_tEKNSt6size_tE", "cudaq::complex_matrix::complex_matrix"], [2, 4, 1, "_CPPv4N5cudaq14complex_matrix14complex_matrixEKNSt6size_tEKNSt6size_tE", "cudaq::complex_matrix::complex_matrix::cols"], [2, 4, 1, "_CPPv4N5cudaq14complex_matrix14complex_matrixEP10value_typeKNSt6size_tEKNSt6size_tE", "cudaq::complex_matrix::complex_matrix::cols"], [2, 4, 1, "_CPPv4N5cudaq14complex_matrix14complex_matrixEP10value_typeKNSt6size_tEKNSt6size_tE", "cudaq::complex_matrix::complex_matrix::rawData"], [2, 4, 1, "_CPPv4N5cudaq14complex_matrix14complex_matrixEKNSt6size_tEKNSt6size_tE", "cudaq::complex_matrix::complex_matrix::rows"], [2, 4, 1, "_CPPv4N5cudaq14complex_matrix14complex_matrixEP10value_typeKNSt6size_tEKNSt6size_tE", "cudaq::complex_matrix::complex_matrix::rows"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrix4dataEv", "cudaq::complex_matrix::data"], [2, 3, 1, "_CPPv4N5cudaq14complex_matrix4dumpERNSt7ostreamE", "cudaq::complex_matrix::dump"], [2, 3, 1, "_CPPv4N5cudaq14complex_matrix4dumpEv", "cudaq::complex_matrix::dump"], [2, 4, 1, "_CPPv4N5cudaq14complex_matrix4dumpERNSt7ostreamE", "cudaq::complex_matrix::dump::os"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrix11eigenvaluesEv", "cudaq::complex_matrix::eigenvalues"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrix12eigenvectorsEv", "cudaq::complex_matrix::eigenvectors"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrix18minimal_eigenvalueEv", "cudaq::complex_matrix::minimal_eigenvalue"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrixclENSt6size_tENSt6size_tE", "cudaq::complex_matrix::operator()"], [2, 4, 1, "_CPPv4NK5cudaq14complex_matrixclENSt6size_tENSt6size_tE", "cudaq::complex_matrix::operator()::i"], [2, 4, 1, "_CPPv4NK5cudaq14complex_matrixclENSt6size_tENSt6size_tE", "cudaq::complex_matrix::operator()::j"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrixmlER14complex_matrix", "cudaq::complex_matrix::operator*"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrixmlERNSt6vectorI10value_typeEE", "cudaq::complex_matrix::operator*"], [2, 4, 1, "_CPPv4NK5cudaq14complex_matrixmlER14complex_matrix", "cudaq::complex_matrix::operator*::other"], [2, 4, 1, "_CPPv4NK5cudaq14complex_matrixmlERNSt6vectorI10value_typeEE", "cudaq::complex_matrix::operator*::other"], [2, 3, 1, "_CPPv4NK5cudaq14complex_matrix4rowsEv", "cudaq::complex_matrix::rows"], [2, 3, 1, "_CPPv4N5cudaq14complex_matrix8set_zeroEv", "cudaq::complex_matrix::set_zero"], [2, 0, 1, "_CPPv4N5cudaq14complex_matrix10value_typeE", "cudaq::complex_matrix::value_type"], [2, 1, 1, "_CPPv4N5cudaq22depolarization_channelE", "cudaq::depolarization_channel"], [2, 0, 1, "_CPPv4N5cudaq7detailsE", "cudaq::details"], [2, 1, 1, "_CPPv4N5cudaq7details17KernelBuilderTypeE", "cudaq::details::KernelBuilderType"], [2, 3, 1, "_CPPv4N5cudaq7details17KernelBuilderType17KernelBuilderTypeERRNSt8functionIFN4mlir4TypeEPN4mlir11MLIRContextEEEE", "cudaq::details::KernelBuilderType::KernelBuilderType"], [2, 4, 1, "_CPPv4N5cudaq7details17KernelBuilderType17KernelBuilderTypeERRNSt8functionIFN4mlir4TypeEPN4mlir11MLIRContextEEEE", "cudaq::details::KernelBuilderType::KernelBuilderType::f"], [2, 3, 1, "_CPPv4N5cudaq7details17KernelBuilderType6createEPN4mlir11MLIRContextE", "cudaq::details::KernelBuilderType::create"], [2, 4, 1, "_CPPv4N5cudaq7details17KernelBuilderType6createEPN4mlir11MLIRContextE", "cudaq::details::KernelBuilderType::create::ctx"], [2, 1, 1, "_CPPv4N5cudaq7details6futureE", "cudaq::details::future"], [2, 3, 1, "_CPPv4N5cudaq7details6future6futureERNSt6vectorI3JobEERNSt6stringERNSt3mapINSt6stringENSt6stringEEE", "cudaq::details::future::future"], [2, 3, 1, "_CPPv4N5cudaq7details6future6futureERR6future", "cudaq::details::future::future"], [2, 3, 1, "_CPPv4N5cudaq7details6future6futureEv", "cudaq::details::future::future"], [2, 4, 1, "_CPPv4N5cudaq7details6future6futureERNSt6vectorI3JobEERNSt6stringERNSt3mapINSt6stringENSt6stringEEE", "cudaq::details::future::future::_jobs"], [2, 4, 1, "_CPPv4N5cudaq7details6future6futureERNSt6vectorI3JobEERNSt6stringERNSt3mapINSt6stringENSt6stringEEE", "cudaq::details::future::future::config"], [2, 4, 1, "_CPPv4N5cudaq7details6future6futureERNSt6vectorI3JobEERNSt6stringERNSt3mapINSt6stringENSt6stringEEE", "cudaq::details::future::future::qpuNameIn"], [2, 1, 1, "_CPPv4N5cudaq7details19kernel_builder_baseE", "cudaq::details::kernel_builder_base"], [2, 3, 1, "_CPPv4N5cudaq7details19kernel_builder_baselsERNSt7ostreamERK19kernel_builder_base", "cudaq::details::kernel_builder_base::operator<<"], [2, 4, 1, "_CPPv4N5cudaq7details19kernel_builder_baselsERNSt7ostreamERK19kernel_builder_base", "cudaq::details::kernel_builder_base::operator<<::builder"], [2, 4, 1, "_CPPv4N5cudaq7details19kernel_builder_baselsERNSt7ostreamERK19kernel_builder_base", "cudaq::details::kernel_builder_base::operator<<::stream"], [2, 3, 1, "_CPPv4I0Dp0EN5cudaq4drawENSt6stringERR13QuantumKernelDpRR4Args", "cudaq::draw"], [2, 2, 1, "_CPPv4I0Dp0EN5cudaq4drawENSt6stringERR13QuantumKernelDpRR4Args", "cudaq::draw::Args"], [2, 2, 1, "_CPPv4I0Dp0EN5cudaq4drawENSt6stringERR13QuantumKernelDpRR4Args", "cudaq::draw::QuantumKernel"], [2, 4, 1, "_CPPv4I0Dp0EN5cudaq4drawENSt6stringERR13QuantumKernelDpRR4Args", "cudaq::draw::args"], [2, 4, 1, "_CPPv4I0Dp0EN5cudaq4drawENSt6stringERR13QuantumKernelDpRR4Args", "cudaq::draw::kernel"], [2, 5, 1, "_CPPv4N5cudaq3dynE", "cudaq::dyn"], [2, 1, 1, "_CPPv4N5cudaq8gradientE", "cudaq::gradient"], [2, 3, 1, "_CPPv4N5cudaq8gradient5cloneEv", "cudaq::gradient::clone"], [2, 3, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradient::compute"], [2, 3, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradient::compute"], [2, 4, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradient::compute::dx"], [2, 4, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradient::compute::func"], [2, 4, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradient::compute::funcAtX"], [2, 4, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradient::compute::funcAtX"], [2, 4, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradient::compute::h"], [2, 4, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradient::compute::x"], [2, 4, 1, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradient::compute::x"], [2, 3, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelT", "cudaq::gradient::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelTRR10ArgsMapper", "cudaq::gradient::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq8gradient8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradient::gradient"], [2, 3, 1, "_CPPv4N5cudaq8gradient8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradient::gradient"], [2, 3, 1, "_CPPv4N5cudaq8gradient8gradientEv", "cudaq::gradient::gradient"], [2, 2, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelTRR10ArgsMapper", "cudaq::gradient::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq8gradient8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradient::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelT", "cudaq::gradient::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelTRR10ArgsMapper", "cudaq::gradient::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq8gradient8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradient::gradient::QuantumKernel"], [2, 4, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelTRR10ArgsMapper", "cudaq::gradient::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq8gradient8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradient::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelT", "cudaq::gradient::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelTRR10ArgsMapper", "cudaq::gradient::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq8gradient8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradient::gradient::kernel"], [2, 4, 1, "_CPPv4N5cudaq8gradient8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradient::gradient::kernel"], [2, 3, 1, "_CPPv4I0DpEN5cudaq8gradient7setArgsEvR13QuantumKernelDpRR4Args", "cudaq::gradient::setArgs"], [2, 2, 1, "_CPPv4I0DpEN5cudaq8gradient7setArgsEvR13QuantumKernelDpRR4Args", "cudaq::gradient::setArgs::Args"], [2, 2, 1, "_CPPv4I0DpEN5cudaq8gradient7setArgsEvR13QuantumKernelDpRR4Args", "cudaq::gradient::setArgs::QuantumKernel"], [2, 4, 1, "_CPPv4I0DpEN5cudaq8gradient7setArgsEvR13QuantumKernelDpRR4Args", "cudaq::gradient::setArgs::args"], [2, 4, 1, "_CPPv4I0DpEN5cudaq8gradient7setArgsEvR13QuantumKernelDpRR4Args", "cudaq::gradient::setArgs::kernel"], [2, 3, 1, "_CPPv4I0EN5cudaq8gradient9setKernelEvR13QuantumKernel", "cudaq::gradient::setKernel"], [2, 2, 1, "_CPPv4I0EN5cudaq8gradient9setKernelEvR13QuantumKernel", "cudaq::gradient::setKernel::QuantumKernel"], [2, 4, 1, "_CPPv4I0EN5cudaq8gradient9setKernelEvR13QuantumKernel", "cudaq::gradient::setKernel::kernel"], [2, 1, 1, "_CPPv4N5cudaq9gradients18central_differenceE", "cudaq::gradients::central_difference"], [2, 3, 1, "_CPPv4N5cudaq9gradients18central_difference5cloneEv", "cudaq::gradients::central_difference::clone"], [2, 3, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::central_difference::compute"], [2, 3, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::central_difference::compute"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::central_difference::compute::dx"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::central_difference::compute::exp_h"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::central_difference::compute::func"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::central_difference::compute::funcAtX"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::central_difference::compute::h"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::central_difference::compute::x"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::central_difference::compute::x"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelT", "cudaq::gradients::central_difference::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::central_difference::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::central_difference::gradient"], [2, 3, 1, "_CPPv4N5cudaq9gradients18central_difference8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradients::central_difference::gradient"], [2, 3, 1, "_CPPv4N5cudaq9gradients18central_difference8gradientEv", "cudaq::gradients::central_difference::gradient"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelT", "cudaq::gradients::central_difference::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::QuantumKernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelT", "cudaq::gradients::central_difference::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::central_difference::gradient::kernel"], [2, 4, 1, "_CPPv4N5cudaq9gradients18central_difference8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradients::central_difference::gradient::kernel"], [2, 1, 1, "_CPPv4N5cudaq9gradients18forward_differenceE", "cudaq::gradients::forward_difference"], [2, 3, 1, "_CPPv4N5cudaq9gradients18forward_difference5cloneEv", "cudaq::gradients::forward_difference::clone"], [2, 3, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::forward_difference::compute"], [2, 3, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::forward_difference::compute"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::forward_difference::compute::dx"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::forward_difference::compute::func"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::forward_difference::compute::funcAtX"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::forward_difference::compute::funcAtX"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::forward_difference::compute::h"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::forward_difference::compute::x"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::forward_difference::compute::x"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelT", "cudaq::gradients::forward_difference::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient"], [2, 3, 1, "_CPPv4N5cudaq9gradients18forward_difference8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradients::forward_difference::gradient"], [2, 3, 1, "_CPPv4N5cudaq9gradients18forward_difference8gradientEv", "cudaq::gradients::forward_difference::gradient"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelT", "cudaq::gradients::forward_difference::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::QuantumKernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelT", "cudaq::gradients::forward_difference::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::forward_difference::gradient::kernel"], [2, 4, 1, "_CPPv4N5cudaq9gradients18forward_difference8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradients::forward_difference::gradient::kernel"], [2, 1, 1, "_CPPv4N5cudaq9gradients15parameter_shiftE", "cudaq::gradients::parameter_shift"], [2, 3, 1, "_CPPv4N5cudaq9gradients15parameter_shift5cloneEv", "cudaq::gradients::parameter_shift::clone"], [2, 3, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::parameter_shift::compute"], [2, 3, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::parameter_shift::compute"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::parameter_shift::compute::dx"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::parameter_shift::compute::exp_h"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::parameter_shift::compute::func"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::parameter_shift::compute::funcAtX"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::parameter_shift::compute::h"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd", "cudaq::gradients::parameter_shift::compute::x"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd", "cudaq::gradients::parameter_shift::compute::x"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelT", "cudaq::gradients::parameter_shift::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient"], [2, 3, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient"], [2, 3, 1, "_CPPv4N5cudaq9gradients15parameter_shift8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradients::parameter_shift::gradient"], [2, 3, 1, "_CPPv4N5cudaq9gradients15parameter_shift8gradientEv", "cudaq::gradients::parameter_shift::gradient"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::ArgsMapper"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelT", "cudaq::gradients::parameter_shift::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::KernelT"], [2, 2, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::QuantumKernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::argsMapper"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelT", "cudaq::gradients::parameter_shift::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelTRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::kernel"], [2, 4, 1, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientERR13QuantumKernelRR10ArgsMapper", "cudaq::gradients::parameter_shift::gradient::kernel"], [2, 4, 1, "_CPPv4N5cudaq9gradients15parameter_shift8gradientERRNSt8functionIFvNSt6vectorIdEEEEE", "cudaq::gradients::parameter_shift::gradient::kernel"], [2, 1, 1, "_CPPv4IDpEN5cudaq14kernel_builderE", "cudaq::kernel_builder"], [2, 2, 1, "_CPPv4IDpEN5cudaq14kernel_builderE", "cudaq::kernel_builder::Args"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder11constantValEd", "cudaq::kernel_builder::constantVal"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder11constantValEd", "cudaq::kernel_builder::constantVal::val"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder12getArgumentsEv", "cudaq::kernel_builder::getArguments"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder12getNumParamsEv", "cudaq::kernel_builder::getNumParams"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder11isArgStdVecENSt6size_tE", "cudaq::kernel_builder::isArgStdVec"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder11isArgStdVecENSt6size_tE", "cudaq::kernel_builder::isArgStdVec::idx"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder14kernel_builderERNSt6vectorIN7details17KernelBuilderTypeEEE", "cudaq::kernel_builder::kernel_builder"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder14kernel_builderERNSt6vectorIN7details17KernelBuilderTypeEEE", "cudaq::kernel_builder::kernel_builder::types"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder4nameEv", "cudaq::kernel_builder::name"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder6qallocE10QuakeValue", "cudaq::kernel_builder::qalloc"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder6qallocEKNSt6size_tE", "cudaq::kernel_builder::qalloc"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder6qallocERNSt6vectorINSt7complexIdEEEE", "cudaq::kernel_builder::qalloc"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder6qallocEv", "cudaq::kernel_builder::qalloc"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder6qallocEKNSt6size_tE", "cudaq::kernel_builder::qalloc::nQubits"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder6qallocE10QuakeValue", "cudaq::kernel_builder::qalloc::size"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder6qallocERNSt6vectorINSt7complexIdEEEE", "cudaq::kernel_builder::qalloc::state"], [2, 3, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRK10QuakeValueRK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap"], [2, 3, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRKNSt6vectorI10QuakeValueEERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap"], [2, 3, 1, "_CPPv4N5cudaq14kernel_builder4swapERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap"], [2, 4, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRK10QuakeValueRK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::control"], [2, 4, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRKNSt6vectorI10QuakeValueEERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::controls"], [2, 4, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRK10QuakeValueRK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::first"], [2, 4, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRKNSt6vectorI10QuakeValueEERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::first"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder4swapERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::first"], [2, 2, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRK10QuakeValueRK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::mod"], [2, 2, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRKNSt6vectorI10QuakeValueEERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::mod"], [2, 4, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRK10QuakeValueRK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::second"], [2, 4, 1, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRKNSt6vectorI10QuakeValueEERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::second"], [2, 4, 1, "_CPPv4N5cudaq14kernel_builder4swapERK10QuakeValueRK10QuakeValue", "cudaq::kernel_builder::swap::second"], [2, 1, 1, "_CPPv4N5cudaq13kraus_channelE", "cudaq::kraus_channel"], [2, 3, 1, "_CPPv4NK5cudaq13kraus_channel5emptyEv", "cudaq::kraus_channel::empty"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channel7get_opsEv", "cudaq::kraus_channel::get_ops"], [2, 3, 1, "_CPPv4IDpEN5cudaq13kraus_channel13kraus_channelEDpRRNSt16initializer_listI1TEE", "cudaq::kraus_channel::kraus_channel"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channel13kraus_channelERK13kraus_channel", "cudaq::kraus_channel::kraus_channel"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channel13kraus_channelERNSt6vectorI8kraus_opEE", "cudaq::kraus_channel::kraus_channel"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channel13kraus_channelERRNSt6vectorI8kraus_opEE", "cudaq::kraus_channel::kraus_channel"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channel13kraus_channelEv", "cudaq::kraus_channel::kraus_channel"], [2, 2, 1, "_CPPv4IDpEN5cudaq13kraus_channel13kraus_channelEDpRRNSt16initializer_listI1TEE", "cudaq::kraus_channel::kraus_channel::T"], [2, 4, 1, "_CPPv4IDpEN5cudaq13kraus_channel13kraus_channelEDpRRNSt16initializer_listI1TEE", "cudaq::kraus_channel::kraus_channel::inputLists"], [2, 4, 1, "_CPPv4N5cudaq13kraus_channel13kraus_channelERNSt6vectorI8kraus_opEE", "cudaq::kraus_channel::kraus_channel::ops"], [2, 4, 1, "_CPPv4N5cudaq13kraus_channel13kraus_channelERRNSt6vectorI8kraus_opEE", "cudaq::kraus_channel::kraus_channel::ops"], [2, 4, 1, "_CPPv4N5cudaq13kraus_channel13kraus_channelERK13kraus_channel", "cudaq::kraus_channel::kraus_channel::other"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channelaSERK13kraus_channel", "cudaq::kraus_channel::operator="], [2, 4, 1, "_CPPv4N5cudaq13kraus_channelaSERK13kraus_channel", "cudaq::kraus_channel::operator=::other"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channelixEKNSt6size_tE", "cudaq::kraus_channel::operator[]"], [2, 4, 1, "_CPPv4N5cudaq13kraus_channelixEKNSt6size_tE", "cudaq::kraus_channel::operator[]::idx"], [2, 3, 1, "_CPPv4N5cudaq13kraus_channel9push_backE8kraus_op", "cudaq::kraus_channel::push_back"], [2, 4, 1, "_CPPv4N5cudaq13kraus_channel9push_backE8kraus_op", "cudaq::kraus_channel::push_back::op"], [2, 3, 1, "_CPPv4NK5cudaq13kraus_channel4sizeEv", "cudaq::kraus_channel::size"], [2, 1, 1, "_CPPv4N5cudaq8kraus_opE", "cudaq::kraus_op"], [2, 3, 1, "_CPPv4NK5cudaq8kraus_op7adjointEv", "cudaq::kraus_op::adjoint"], [2, 5, 1, "_CPPv4N5cudaq8kraus_op4dataE", "cudaq::kraus_op::data"], [2, 3, 1, "_CPPv4I0EN5cudaq8kraus_op8kraus_opERRNSt16initializer_listI1TEE", "cudaq::kraus_op::kraus_op"], [2, 3, 1, "_CPPv4N5cudaq8kraus_op8kraus_opENSt6vectorIN5cudaq7complexEEE", "cudaq::kraus_op::kraus_op"], [2, 3, 1, "_CPPv4N5cudaq8kraus_op8kraus_opERK8kraus_op", "cudaq::kraus_op::kraus_op"], [2, 2, 1, "_CPPv4I0EN5cudaq8kraus_op8kraus_opERRNSt16initializer_listI1TEE", "cudaq::kraus_op::kraus_op::T"], [2, 4, 1, "_CPPv4N5cudaq8kraus_op8kraus_opENSt6vectorIN5cudaq7complexEEE", "cudaq::kraus_op::kraus_op::d"], [2, 4, 1, "_CPPv4I0EN5cudaq8kraus_op8kraus_opERRNSt16initializer_listI1TEE", "cudaq::kraus_op::kraus_op::initList"], [2, 5, 1, "_CPPv4N5cudaq8kraus_op5nColsE", "cudaq::kraus_op::nCols"], [2, 5, 1, "_CPPv4N5cudaq8kraus_op5nRowsE", "cudaq::kraus_op::nRows"], [2, 3, 1, "_CPPv4N5cudaq8kraus_opaSERK8kraus_op", "cudaq::kraus_op::operator="], [2, 4, 1, "_CPPv4N5cudaq8kraus_opaSERK8kraus_op", "cudaq::kraus_op::operator=::other"], [2, 0, 1, "_CPPv4N5cudaq3mpiE", "cudaq::mpi"], [2, 3, 1, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIdEERKNSt6vectorIdEE", "cudaq::mpi::all_gather"], [2, 3, 1, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIiEERKNSt6vectorIiEE", "cudaq::mpi::all_gather"], [2, 4, 1, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIdEERKNSt6vectorIdEE", "cudaq::mpi::all_gather::global"], [2, 4, 1, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIiEERKNSt6vectorIiEE", "cudaq::mpi::all_gather::global"], [2, 4, 1, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIdEERKNSt6vectorIdEE", "cudaq::mpi::all_gather::local"], [2, 4, 1, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIiEERKNSt6vectorIiEE", "cudaq::mpi::all_gather::local"], [2, 3, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK14BinaryFunction", "cudaq::mpi::all_reduce"], [2, 3, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK4Func", "cudaq::mpi::all_reduce"], [2, 2, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK14BinaryFunction", "cudaq::mpi::all_reduce::BinaryFunction"], [2, 2, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK4Func", "cudaq::mpi::all_reduce::Func"], [2, 2, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK14BinaryFunction", "cudaq::mpi::all_reduce::T"], [2, 2, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK4Func", "cudaq::mpi::all_reduce::T"], [2, 4, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK14BinaryFunction", "cudaq::mpi::all_reduce::function"], [2, 4, 1, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK14BinaryFunction", "cudaq::mpi::all_reduce::localValue"], [2, 3, 1, "_CPPv4N5cudaq3mpi9broadcastERNSt6stringEi", "cudaq::mpi::broadcast"], [2, 3, 1, "_CPPv4N5cudaq3mpi9broadcastERNSt6vectorIdEEi", "cudaq::mpi::broadcast"], [2, 4, 1, "_CPPv4N5cudaq3mpi9broadcastERNSt6stringEi", "cudaq::mpi::broadcast::data"], [2, 4, 1, "_CPPv4N5cudaq3mpi9broadcastERNSt6vectorIdEEi", "cudaq::mpi::broadcast::data"], [2, 4, 1, "_CPPv4N5cudaq3mpi9broadcastERNSt6stringEi", "cudaq::mpi::broadcast::rootRank"], [2, 4, 1, "_CPPv4N5cudaq3mpi9broadcastERNSt6vectorIdEEi", "cudaq::mpi::broadcast::rootRank"], [2, 3, 1, "_CPPv4N5cudaq3mpi8finalizeEv", "cudaq::mpi::finalize"], [2, 3, 1, "_CPPv4N5cudaq3mpi10initializeEiPPc", "cudaq::mpi::initialize"], [2, 3, 1, "_CPPv4N5cudaq3mpi10initializeEv", "cudaq::mpi::initialize"], [2, 4, 1, "_CPPv4N5cudaq3mpi10initializeEiPPc", "cudaq::mpi::initialize::argc"], [2, 4, 1, "_CPPv4N5cudaq3mpi10initializeEiPPc", "cudaq::mpi::initialize::argv"], [2, 3, 1, "_CPPv4N5cudaq3mpi14is_initializedEv", "cudaq::mpi::is_initialized"], [2, 3, 1, "_CPPv4N5cudaq3mpi9num_ranksEv", "cudaq::mpi::num_ranks"], [2, 3, 1, "_CPPv4N5cudaq3mpi4rankEv", "cudaq::mpi::rank"], [2, 1, 1, "_CPPv4N5cudaq11noise_modelE", "cudaq::noise_model"], [2, 3, 1, "_CPPv4IDpEN5cudaq11noise_model11add_channelEvRKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel"], [2, 3, 1, "_CPPv4N5cudaq11noise_model11add_channelERKNSt6stringERKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel"], [2, 2, 1, "_CPPv4IDpEN5cudaq11noise_model11add_channelEvRKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel::QuantumOp"], [2, 4, 1, "_CPPv4IDpEN5cudaq11noise_model11add_channelEvRKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel::channel"], [2, 4, 1, "_CPPv4N5cudaq11noise_model11add_channelERKNSt6stringERKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel::channel"], [2, 4, 1, "_CPPv4N5cudaq11noise_model11add_channelERKNSt6stringERKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel::quantumOp"], [2, 4, 1, "_CPPv4IDpEN5cudaq11noise_model11add_channelEvRKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel::qubits"], [2, 4, 1, "_CPPv4N5cudaq11noise_model11add_channelERKNSt6stringERKNSt6vectorINSt6size_tEEERK13kraus_channel", "cudaq::noise_model::add_channel::qubits"], [2, 3, 1, "_CPPv4NK5cudaq11noise_model5emptyEv", "cudaq::noise_model::empty"], [2, 3, 1, "_CPPv4I0ENK5cudaq11noise_model12get_channelsENSt6vectorI13kraus_channelEERKNSt6vectorINSt6size_tEEE", "cudaq::noise_model::get_channels"], [2, 3, 1, "_CPPv4NK5cudaq11noise_model12get_channelsERKNSt6stringERKNSt6vectorINSt6size_tEEE", "cudaq::noise_model::get_channels"], [2, 2, 1, "_CPPv4I0ENK5cudaq11noise_model12get_channelsENSt6vectorI13kraus_channelEERKNSt6vectorINSt6size_tEEE", "cudaq::noise_model::get_channels::QuantumOp"], [2, 4, 1, "_CPPv4NK5cudaq11noise_model12get_channelsERKNSt6stringERKNSt6vectorINSt6size_tEEE", "cudaq::noise_model::get_channels::quantumOp"], [2, 4, 1, "_CPPv4I0ENK5cudaq11noise_model12get_channelsENSt6vectorI13kraus_channelEERKNSt6vectorINSt6size_tEEE", "cudaq::noise_model::get_channels::qubits"], [2, 4, 1, "_CPPv4NK5cudaq11noise_model12get_channelsERKNSt6stringERKNSt6vectorINSt6size_tEEE", "cudaq::noise_model::get_channels::qubits"], [2, 3, 1, "_CPPv4N5cudaq11noise_model11noise_modelEv", "cudaq::noise_model::noise_model"], [2, 3, 1, "_CPPv4N5cudaq18num_available_gpusEv", "cudaq::num_available_gpus"], [2, 1, 1, "_CPPv4N5cudaq14observe_resultE", "cudaq::observe_result"], [2, 3, 1, "_CPPv4I0EN5cudaq14observe_result6countsE13sample_result10SpinOpType", "cudaq::observe_result::counts"], [2, 2, 1, "_CPPv4I0EN5cudaq14observe_result6countsE13sample_result10SpinOpType", "cudaq::observe_result::counts::SpinOpType"], [2, 4, 1, "_CPPv4I0EN5cudaq14observe_result6countsE13sample_result10SpinOpType", "cudaq::observe_result::counts::term"], [2, 3, 1, "_CPPv4N5cudaq14observe_result4dumpEv", "cudaq::observe_result::dump"], [2, 3, 1, "_CPPv4I0EN5cudaq14observe_result11expectationEd10SpinOpType", "cudaq::observe_result::expectation"], [2, 3, 1, "_CPPv4N5cudaq14observe_result11expectationEv", "cudaq::observe_result::expectation"], [2, 2, 1, "_CPPv4I0EN5cudaq14observe_result11expectationEd10SpinOpType", "cudaq::observe_result::expectation::SpinOpType"], [2, 4, 1, "_CPPv4I0EN5cudaq14observe_result11expectationEd10SpinOpType", "cudaq::observe_result::expectation::term"], [2, 3, 1, "_CPPv4N5cudaq14observe_result14id_coefficientEv", "cudaq::observe_result::id_coefficient"], [2, 3, 1, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op", "cudaq::observe_result::observe_result"], [2, 3, 1, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op13sample_result", "cudaq::observe_result::observe_result"], [2, 4, 1, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op", "cudaq::observe_result::observe_result::H"], [2, 4, 1, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op13sample_result", "cudaq::observe_result::observe_result::H"], [2, 4, 1, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op13sample_result", "cudaq::observe_result::observe_result::counts"], [2, 4, 1, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op", "cudaq::observe_result::observe_result::e"], [2, 4, 1, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op13sample_result", "cudaq::observe_result::observe_result::e"], [2, 3, 1, "_CPPv4N5cudaq14observe_resultcvdEv", "cudaq::observe_result::operator double"], [2, 3, 1, "_CPPv4N5cudaq14observe_result8raw_dataEv", "cudaq::observe_result::raw_data"], [2, 1, 1, "_CPPv4N5cudaq20optimizable_functionE", "cudaq::optimizable_function"], [2, 0, 1, "_CPPv4N5cudaq19optimization_resultE", "cudaq::optimization_result"], [2, 1, 1, "_CPPv4N5cudaq9optimizerE", "cudaq::optimizer"], [2, 3, 1, "_CPPv4N5cudaq9optimizer8optimizeEKiRR20optimizable_function", "cudaq::optimizer::optimize"], [2, 4, 1, "_CPPv4N5cudaq9optimizer8optimizeEKiRR20optimizable_function", "cudaq::optimizer::optimize::dim"], [2, 4, 1, "_CPPv4N5cudaq9optimizer8optimizeEKiRR20optimizable_function", "cudaq::optimizer::optimize::opt_function"], [2, 3, 1, "_CPPv4N5cudaq9optimizer17requiresGradientsEv", "cudaq::optimizer::requiresGradients"], [2, 1, 1, "_CPPv4N5cudaq18phase_flip_channelE", "cudaq::phase_flip_channel"], [2, 1, 1, "_CPPv4I_NSt6size_tE_NSt6size_tE0EN5cudaq4qregE", "cudaq::qreg"], [2, 2, 1, "_CPPv4I_NSt6size_tE_NSt6size_tE0EN5cudaq4qregE", "cudaq::qreg::Levels"], [2, 2, 1, "_CPPv4I_NSt6size_tE_NSt6size_tE0EN5cudaq4qregE", "cudaq::qreg::N"], [2, 3, 1, "_CPPv4N5cudaq4qreg4backENSt6size_tE", "cudaq::qreg::back"], [2, 3, 1, "_CPPv4N5cudaq4qreg4backEv", "cudaq::qreg::back"], [2, 4, 1, "_CPPv4N5cudaq4qreg4backENSt6size_tE", "cudaq::qreg::back::count"], [2, 3, 1, "_CPPv4N5cudaq4qreg5beginEv", "cudaq::qreg::begin"], [2, 3, 1, "_CPPv4N5cudaq4qreg5clearEv", "cudaq::qreg::clear"], [2, 3, 1, "_CPPv4N5cudaq4qreg5frontENSt6size_tE", "cudaq::qreg::front"], [2, 3, 1, "_CPPv4N5cudaq4qreg5frontEv", "cudaq::qreg::front"], [2, 4, 1, "_CPPv4N5cudaq4qreg5frontENSt6size_tE", "cudaq::qreg::front::count"], [2, 3, 1, "_CPPv4N5cudaq4qregixEKNSt6size_tE", "cudaq::qreg::operator[]"], [2, 4, 1, "_CPPv4N5cudaq4qregixEKNSt6size_tE", "cudaq::qreg::operator[]::idx"], [2, 3, 1, "_CPPv4NK5cudaq4qreg4sizeEv", "cudaq::qreg::size"], [2, 3, 1, "_CPPv4N5cudaq4qreg5sliceENSt6size_tENSt6size_tE", "cudaq::qreg::slice"], [2, 4, 1, "_CPPv4N5cudaq4qreg5sliceENSt6size_tENSt6size_tE", "cudaq::qreg::slice::size"], [2, 4, 1, "_CPPv4N5cudaq4qreg5sliceENSt6size_tENSt6size_tE", "cudaq::qreg::slice::start"], [2, 0, 1, "_CPPv4N5cudaq4qreg10value_typeE", "cudaq::qreg::value_type"], [2, 1, 1, "_CPPv4I_NSt6size_tE_NSt6size_tEEN5cudaq5qspanE", "cudaq::qspan"], [2, 2, 1, "_CPPv4I_NSt6size_tE_NSt6size_tEEN5cudaq5qspanE", "cudaq::qspan::Levels"], [2, 2, 1, "_CPPv4I_NSt6size_tE_NSt6size_tEEN5cudaq5qspanE", "cudaq::qspan::N"], [2, 1, 1, "_CPPv4N5cudaq16quantum_platformE", "cudaq::quantum_platform"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform11clear_shotsEv", "cudaq::quantum_platform::clear_shots"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform12connectivityEv", "cudaq::quantum_platform::connectivity"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tER19KernelExecutionTask", "cudaq::quantum_platform::enqueueAsyncTask"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tERNSt8functionIFvvEEE", "cudaq::quantum_platform::enqueueAsyncTask"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tERNSt8functionIFvvEEE", "cudaq::quantum_platform::enqueueAsyncTask::f"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tER19KernelExecutionTask", "cudaq::quantum_platform::enqueueAsyncTask::qpu_id"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tERNSt8functionIFvvEEE", "cudaq::quantum_platform::enqueueAsyncTask::qpu_id"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tER19KernelExecutionTask", "cudaq::quantum_platform::enqueueAsyncTask::t"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform12getLogStreamEv", "cudaq::quantum_platform::getLogStream"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform15get_current_qpuEv", "cudaq::quantum_platform::get_current_qpu"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform12get_exec_ctxEv", "cudaq::quantum_platform::get_exec_ctx"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform14get_num_qubitsENSt6size_tE", "cudaq::quantum_platform::get_num_qubits"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform14get_num_qubitsEv", "cudaq::quantum_platform::get_num_qubits"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform14get_num_qubitsENSt6size_tE", "cudaq::quantum_platform::get_num_qubits::qpu_id"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform23get_remote_capabilitiesEKNSt6size_tE", "cudaq::quantum_platform::get_remote_capabilities"], [2, 4, 1, "_CPPv4NK5cudaq16quantum_platform23get_remote_capabilitiesEKNSt6size_tE", "cudaq::quantum_platform::get_remote_capabilities::qpuId"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform9get_shotsEv", "cudaq::quantum_platform::get_shots"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform11is_emulatedEKNSt6size_tE", "cudaq::quantum_platform::is_emulated"], [2, 4, 1, "_CPPv4NK5cudaq16quantum_platform11is_emulatedEKNSt6size_tE", "cudaq::quantum_platform::is_emulated::qpuId"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform9is_remoteEKNSt6size_tE", "cudaq::quantum_platform::is_remote"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9is_remoteEKNSt6size_tE", "cudaq::quantum_platform::is_remote::qpuId"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform12is_simulatorEKNSt6size_tE", "cudaq::quantum_platform::is_simulator"], [2, 4, 1, "_CPPv4NK5cudaq16quantum_platform12is_simulatorEKNSt6size_tE", "cudaq::quantum_platform::is_simulator::qpu_id"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE::H"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE::gradient"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE::kernelArgs"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE::kernelName"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE::n_params"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE::optimizer"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE", "cudaq::quantum_platform::launchVQE::shots"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform14list_platformsEv", "cudaq::quantum_platform::list_platforms"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform4nameEv", "cudaq::quantum_platform::name"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform8num_qpusEv", "cudaq::quantum_platform::num_qpus"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform15onRandomSeedSetENSt6size_tE", "cudaq::quantum_platform::onRandomSeedSet"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform15onRandomSeedSetENSt6size_tE", "cudaq::quantum_platform::onRandomSeedSet::seed"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform14resetLogStreamEv", "cudaq::quantum_platform::resetLogStream"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform14reset_exec_ctxENSt6size_tE", "cudaq::quantum_platform::reset_exec_ctx"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform14reset_exec_ctxENSt6size_tE", "cudaq::quantum_platform::reset_exec_ctx::qpu_id"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform11reset_noiseEv", "cudaq::quantum_platform::reset_noise"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform12setLogStreamERNSt7ostreamE", "cudaq::quantum_platform::setLogStream"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform12setLogStreamERNSt7ostreamE", "cudaq::quantum_platform::setLogStream::logStream"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform16setTargetBackendERKNSt6stringE", "cudaq::quantum_platform::setTargetBackend"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform16setTargetBackendERKNSt6stringE", "cudaq::quantum_platform::setTargetBackend::name"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform15set_current_qpuEKNSt6size_tE", "cudaq::quantum_platform::set_current_qpu"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform15set_current_qpuEKNSt6size_tE", "cudaq::quantum_platform::set_current_qpu::device_id"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform12set_exec_ctxEPN5cudaq16ExecutionContextENSt6size_tE", "cudaq::quantum_platform::set_exec_ctx"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform12set_exec_ctxEPN5cudaq16ExecutionContextENSt6size_tE", "cudaq::quantum_platform::set_exec_ctx::ctx"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform12set_exec_ctxEPN5cudaq16ExecutionContextENSt6size_tE", "cudaq::quantum_platform::set_exec_ctx::qpu_id"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform9set_noiseEPK11noise_model", "cudaq::quantum_platform::set_noise"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9set_noiseEPK11noise_model", "cudaq::quantum_platform::set_noise::model"], [2, 3, 1, "_CPPv4N5cudaq16quantum_platform9set_shotsEi", "cudaq::quantum_platform::set_shots"], [2, 4, 1, "_CPPv4N5cudaq16quantum_platform9set_shotsEi", "cudaq::quantum_platform::set_shots::numShots"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform29supports_conditional_feedbackEKNSt6size_tE", "cudaq::quantum_platform::supports_conditional_feedback"], [2, 4, 1, "_CPPv4NK5cudaq16quantum_platform29supports_conditional_feedbackEKNSt6size_tE", "cudaq::quantum_platform::supports_conditional_feedback::qpu_id"], [2, 3, 1, "_CPPv4NK5cudaq16quantum_platform26supports_task_distributionEv", "cudaq::quantum_platform::supports_task_distribution"], [2, 0, 1, "_CPPv4N5cudaq5qubitE", "cudaq::qubit"], [2, 1, 1, "_CPPv4I_NSt6size_tEEN5cudaq5quditE", "cudaq::qudit"], [2, 2, 1, "_CPPv4I_NSt6size_tEEN5cudaq5quditE", "cudaq::qudit::Levels"], [2, 3, 1, "_CPPv4N5cudaq5qudit5quditEv", "cudaq::qudit::qudit"], [2, 1, 1, "_CPPv4I_NSt6size_tEEN5cudaq7qvectorE", "cudaq::qvector"], [2, 2, 1, "_CPPv4I_NSt6size_tEEN5cudaq7qvectorE", "cudaq::qvector::Levels"], [2, 3, 1, "_CPPv4N5cudaq7qvector4backENSt6size_tE", "cudaq::qvector::back"], [2, 3, 1, "_CPPv4N5cudaq7qvector4backEv", "cudaq::qvector::back"], [2, 4, 1, "_CPPv4N5cudaq7qvector4backENSt6size_tE", "cudaq::qvector::back::count"], [2, 3, 1, "_CPPv4N5cudaq7qvector5beginEv", "cudaq::qvector::begin"], [2, 3, 1, "_CPPv4N5cudaq7qvector5clearEv", "cudaq::qvector::clear"], [2, 3, 1, "_CPPv4N5cudaq7qvector3endEv", "cudaq::qvector::end"], [2, 3, 1, "_CPPv4N5cudaq7qvector5frontENSt6size_tE", "cudaq::qvector::front"], [2, 3, 1, "_CPPv4N5cudaq7qvector5frontEv", "cudaq::qvector::front"], [2, 4, 1, "_CPPv4N5cudaq7qvector5frontENSt6size_tE", "cudaq::qvector::front::count"], [2, 3, 1, "_CPPv4N5cudaq7qvectoraSERK7qvector", "cudaq::qvector::operator="], [2, 3, 1, "_CPPv4N5cudaq7qvectorixEKNSt6size_tE", "cudaq::qvector::operator[]"], [2, 4, 1, "_CPPv4N5cudaq7qvectorixEKNSt6size_tE", "cudaq::qvector::operator[]::idx"], [2, 3, 1, "_CPPv4N5cudaq7qvector7qvectorENSt6size_tE", "cudaq::qvector::qvector"], [2, 3, 1, "_CPPv4N5cudaq7qvector7qvectorERK5state", "cudaq::qvector::qvector"], [2, 3, 1, "_CPPv4N5cudaq7qvector7qvectorERK7qvector", "cudaq::qvector::qvector"], [2, 3, 1, "_CPPv4N5cudaq7qvector7qvectorERKNSt6vectorI7complexEEb", "cudaq::qvector::qvector"], [2, 3, 1, "_CPPv4N5cudaq7qvector7qvectorERR7qvector", "cudaq::qvector::qvector"], [2, 4, 1, "_CPPv4N5cudaq7qvector7qvectorENSt6size_tE", "cudaq::qvector::qvector::size"], [2, 4, 1, "_CPPv4N5cudaq7qvector7qvectorERK5state", "cudaq::qvector::qvector::state"], [2, 4, 1, "_CPPv4N5cudaq7qvector7qvectorERKNSt6vectorI7complexEEb", "cudaq::qvector::qvector::validate"], [2, 4, 1, "_CPPv4N5cudaq7qvector7qvectorERKNSt6vectorI7complexEEb", "cudaq::qvector::qvector::vector"], [2, 3, 1, "_CPPv4NK5cudaq7qvector4sizeEv", "cudaq::qvector::size"], [2, 3, 1, "_CPPv4N5cudaq7qvector5sliceENSt6size_tENSt6size_tE", "cudaq::qvector::slice"], [2, 4, 1, "_CPPv4N5cudaq7qvector5sliceENSt6size_tENSt6size_tE", "cudaq::qvector::slice::size"], [2, 4, 1, "_CPPv4N5cudaq7qvector5sliceENSt6size_tENSt6size_tE", "cudaq::qvector::slice::start"], [2, 0, 1, "_CPPv4N5cudaq7qvector10value_typeE", "cudaq::qvector::value_type"], [2, 1, 1, "_CPPv4I_NSt6size_tEEN5cudaq5qviewE", "cudaq::qview"], [2, 2, 1, "_CPPv4I_NSt6size_tEEN5cudaq5qviewE", "cudaq::qview::Levels"], [2, 0, 1, "_CPPv4N5cudaq5qview10value_typeE", "cudaq::qview::value_type"], [2, 3, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType", "cudaq::range"], [2, 3, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType11ElementType11ElementType", "cudaq::range"], [2, 3, 1, "_CPPv4N5cudaq5rangeENSt6size_tE", "cudaq::range"], [2, 2, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType", "cudaq::range::ElementType"], [2, 2, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType11ElementType11ElementType", "cudaq::range::ElementType"], [2, 4, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType", "cudaq::range::N"], [2, 4, 1, "_CPPv4N5cudaq5rangeENSt6size_tE", "cudaq::range::N"], [2, 4, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType11ElementType11ElementType", "cudaq::range::start"], [2, 4, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType11ElementType11ElementType", "cudaq::range::step"], [2, 4, 1, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType11ElementType11ElementType", "cudaq::range::stop"], [2, 0, 1, "_CPPv4N5cudaq4realE", "cudaq::real"], [2, 0, 1, "_CPPv4N5cudaq8registryE", "cudaq::registry"], [2, 1, 1, "_CPPv4I0EN5cudaq8registry14RegisteredTypeE", "cudaq::registry::RegisteredType"], [2, 2, 1, "_CPPv4I0EN5cudaq8registry14RegisteredTypeE", "cudaq::registry::RegisteredType::T"], [2, 1, 1, "_CPPv4N5cudaq13sample_resultE", "cudaq::sample_result"], [2, 3, 1, "_CPPv4N5cudaq13sample_result6appendER15ExecutionResult", "cudaq::sample_result::append"], [2, 4, 1, "_CPPv4N5cudaq13sample_result6appendER15ExecutionResult", "cudaq::sample_result::append::result"], [2, 3, 1, "_CPPv4N5cudaq13sample_result5beginEv", "cudaq::sample_result::begin"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result5beginEv", "cudaq::sample_result::begin"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result6cbeginEv", "cudaq::sample_result::cbegin"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result4cendEv", "cudaq::sample_result::cend"], [2, 3, 1, "_CPPv4N5cudaq13sample_result5clearEv", "cudaq::sample_result::clear"], [2, 3, 1, "_CPPv4N5cudaq13sample_result5countENSt11string_viewEKNSt11string_viewE", "cudaq::sample_result::count"], [2, 4, 1, "_CPPv4N5cudaq13sample_result5countENSt11string_viewEKNSt11string_viewE", "cudaq::sample_result::count::bitString"], [2, 4, 1, "_CPPv4N5cudaq13sample_result5countENSt11string_viewEKNSt11string_viewE", "cudaq::sample_result::count::registerName"], [2, 3, 1, "_CPPv4N5cudaq13sample_result11deserializeERNSt6vectorINSt6size_tEEE", "cudaq::sample_result::deserialize"], [2, 4, 1, "_CPPv4N5cudaq13sample_result11deserializeERNSt6vectorINSt6size_tEEE", "cudaq::sample_result::deserialize::data"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result4dumpERNSt7ostreamE", "cudaq::sample_result::dump"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result4dumpEv", "cudaq::sample_result::dump"], [2, 4, 1, "_CPPv4NK5cudaq13sample_result4dumpERNSt7ostreamE", "cudaq::sample_result::dump::os"], [2, 3, 1, "_CPPv4N5cudaq13sample_result3endEv", "cudaq::sample_result::end"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result3endEv", "cudaq::sample_result::end"], [2, 3, 1, "_CPPv4N5cudaq13sample_result9exp_val_zEKNSt11string_viewE", "cudaq::sample_result::exp_val_z"], [2, 4, 1, "_CPPv4N5cudaq13sample_result9exp_val_zEKNSt11string_viewE", "cudaq::sample_result::exp_val_z::registerName"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result11expectationEKNSt11string_viewE", "cudaq::sample_result::expectation"], [2, 4, 1, "_CPPv4NK5cudaq13sample_result11expectationEKNSt11string_viewE", "cudaq::sample_result::expectation::registerName"], [2, 3, 1, "_CPPv4N5cudaq13sample_result12get_marginalERKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::get_marginal"], [2, 3, 1, "_CPPv4N5cudaq13sample_result12get_marginalERRKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::get_marginal"], [2, 4, 1, "_CPPv4N5cudaq13sample_result12get_marginalERKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::get_marginal::marginalIndices"], [2, 4, 1, "_CPPv4N5cudaq13sample_result12get_marginalERRKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::get_marginal::marginalIndices"], [2, 4, 1, "_CPPv4N5cudaq13sample_result12get_marginalERKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::get_marginal::registerName"], [2, 4, 1, "_CPPv4N5cudaq13sample_result12get_marginalERRKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::get_marginal::registerName"], [2, 3, 1, "_CPPv4N5cudaq13sample_result15has_even_parityENSt11string_viewE", "cudaq::sample_result::has_even_parity"], [2, 4, 1, "_CPPv4N5cudaq13sample_result15has_even_parityENSt11string_viewE", "cudaq::sample_result::has_even_parity::bitString"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result15has_expectationEKNSt11string_viewE", "cudaq::sample_result::has_expectation"], [2, 4, 1, "_CPPv4NK5cudaq13sample_result15has_expectationEKNSt11string_viewE", "cudaq::sample_result::has_expectation::registerName"], [2, 3, 1, "_CPPv4N5cudaq13sample_result13most_probableEKNSt11string_viewE", "cudaq::sample_result::most_probable"], [2, 4, 1, "_CPPv4N5cudaq13sample_result13most_probableEKNSt11string_viewE", "cudaq::sample_result::most_probable::registerName"], [2, 3, 1, "_CPPv4N5cudaq13sample_resultpLERK13sample_result", "cudaq::sample_result::operator+="], [2, 4, 1, "_CPPv4N5cudaq13sample_resultpLERK13sample_result", "cudaq::sample_result::operator+=::other"], [2, 3, 1, "_CPPv4N5cudaq13sample_resultaSER13sample_result", "cudaq::sample_result::operator="], [2, 4, 1, "_CPPv4N5cudaq13sample_resultaSER13sample_result", "cudaq::sample_result::operator=::counts"], [2, 3, 1, "_CPPv4NK5cudaq13sample_resulteqERK13sample_result", "cudaq::sample_result::operator=="], [2, 4, 1, "_CPPv4NK5cudaq13sample_resulteqERK13sample_result", "cudaq::sample_result::operator==::counts"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result11probabilityENSt11string_viewEKNSt11string_viewE", "cudaq::sample_result::probability"], [2, 4, 1, "_CPPv4NK5cudaq13sample_result11probabilityENSt11string_viewEKNSt11string_viewE", "cudaq::sample_result::probability::bitString"], [2, 4, 1, "_CPPv4NK5cudaq13sample_result11probabilityENSt11string_viewEKNSt11string_viewE", "cudaq::sample_result::probability::registerName"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result14register_namesEv", "cudaq::sample_result::register_names"], [2, 3, 1, "_CPPv4N5cudaq13sample_result7reorderERKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::reorder"], [2, 4, 1, "_CPPv4N5cudaq13sample_result7reorderERKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::reorder::index"], [2, 4, 1, "_CPPv4N5cudaq13sample_result7reorderERKNSt6vectorINSt6size_tEEEKNSt11string_viewE", "cudaq::sample_result::reorder::registerName"], [2, 3, 1, "_CPPv4N5cudaq13sample_result13sample_resultER15ExecutionResult", "cudaq::sample_result::sample_result"], [2, 3, 1, "_CPPv4N5cudaq13sample_result13sample_resultERK13sample_result", "cudaq::sample_result::sample_result"], [2, 3, 1, "_CPPv4N5cudaq13sample_result13sample_resultERNSt6vectorI15ExecutionResultEE", "cudaq::sample_result::sample_result"], [2, 3, 1, "_CPPv4N5cudaq13sample_result13sample_resultERR15ExecutionResult", "cudaq::sample_result::sample_result"], [2, 3, 1, "_CPPv4N5cudaq13sample_result13sample_resultEdRNSt6vectorI15ExecutionResultEE", "cudaq::sample_result::sample_result"], [2, 3, 1, "_CPPv4N5cudaq13sample_result13sample_resultEv", "cudaq::sample_result::sample_result"], [2, 4, 1, "_CPPv4N5cudaq13sample_result13sample_resultEdRNSt6vectorI15ExecutionResultEE", "cudaq::sample_result::sample_result::preComputedExp"], [2, 4, 1, "_CPPv4N5cudaq13sample_result13sample_resultER15ExecutionResult", "cudaq::sample_result::sample_result::result"], [2, 4, 1, "_CPPv4N5cudaq13sample_result13sample_resultERR15ExecutionResult", "cudaq::sample_result::sample_result::result"], [2, 4, 1, "_CPPv4N5cudaq13sample_result13sample_resultERNSt6vectorI15ExecutionResultEE", "cudaq::sample_result::sample_result::results"], [2, 4, 1, "_CPPv4N5cudaq13sample_result13sample_resultEdRNSt6vectorI15ExecutionResultEE", "cudaq::sample_result::sample_result::results"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result9serializeEv", "cudaq::sample_result::serialize"], [2, 3, 1, "_CPPv4N5cudaq13sample_result4sizeEKNSt11string_viewE", "cudaq::sample_result::size"], [2, 4, 1, "_CPPv4N5cudaq13sample_result4sizeEKNSt11string_viewE", "cudaq::sample_result::size::registerName"], [2, 3, 1, "_CPPv4NK5cudaq13sample_result6to_mapEKNSt11string_viewE", "cudaq::sample_result::to_map"], [2, 4, 1, "_CPPv4NK5cudaq13sample_result6to_mapEKNSt11string_viewE", "cudaq::sample_result::to_map::registerName"], [2, 3, 1, "_CPPv4N5cudaq13sample_resultD0Ev", "cudaq::sample_result::~sample_result"], [2, 3, 1, "_CPPv4N5cudaq9set_noiseERKN5cudaq11noise_modelE", "cudaq::set_noise"], [2, 4, 1, "_CPPv4N5cudaq9set_noiseERKN5cudaq11noise_modelE", "cudaq::set_noise::model"], [2, 3, 1, "_CPPv4N5cudaq15set_random_seedENSt6size_tE", "cudaq::set_random_seed"], [2, 4, 1, "_CPPv4N5cudaq15set_random_seedENSt6size_tE", "cudaq::set_random_seed::seed"], [2, 6, 1, "_CPPv4N5cudaq20simulation_precisionE", "cudaq::simulation_precision"], [2, 7, 1, "_CPPv4N5cudaq20simulation_precision4fp32E", "cudaq::simulation_precision::fp32"], [2, 7, 1, "_CPPv4N5cudaq20simulation_precision4fp64E", "cudaq::simulation_precision::fp64"], [2, 1, 1, "_CPPv4N5cudaq7spin_opE", "cudaq::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op5beginEv", "cudaq::spin_op::begin"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op5beginEv", "cudaq::spin_op::begin"], [2, 0, 1, "_CPPv4N5cudaq7spin_op12csr_spmatrixE", "cudaq::spin_op::csr_spmatrix"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op16distribute_termsENSt6size_tE", "cudaq::spin_op::distribute_terms"], [2, 4, 1, "_CPPv4NK5cudaq7spin_op16distribute_termsENSt6size_tE", "cudaq::spin_op::distribute_terms::numChunks"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op4dumpEv", "cudaq::spin_op::dump"], [2, 3, 1, "_CPPv4N5cudaq7spin_op3endEv", "cudaq::spin_op::end"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op3endEv", "cudaq::spin_op::end"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op14for_each_pauliERRNSt8functionIFv5pauliNSt6size_tEEEE", "cudaq::spin_op::for_each_pauli"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op13for_each_termERRNSt8functionIFvR7spin_opEEE", "cudaq::spin_op::for_each_term"], [2, 3, 1, "_CPPv4N5cudaq7spin_op9from_wordERKNSt6stringE", "cudaq::spin_op::from_word"], [2, 4, 1, "_CPPv4N5cudaq7spin_op9from_wordERKNSt6stringE", "cudaq::spin_op::from_word::pauliWord"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op21getDataRepresentationEv", "cudaq::spin_op::getDataRepresentation"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op12getDataTupleEv", "cudaq::spin_op::getDataTuple"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op15get_coefficientEv", "cudaq::spin_op::get_coefficient"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op12get_raw_dataEv", "cudaq::spin_op::get_raw_data"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op11is_identityEv", "cudaq::spin_op::is_identity"], [2, 1, 1, "_CPPv4I0EN5cudaq7spin_op8iteratorE", "cudaq::spin_op::iterator"], [2, 2, 1, "_CPPv4I0EN5cudaq7spin_op8iteratorE", "cudaq::spin_op::iterator::QualifiedSpinOp"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op10num_qubitsEv", "cudaq::spin_op::num_qubits"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op9num_termsEv", "cudaq::spin_op::num_terms"], [2, 3, 1, "_CPPv4N5cudaq7spin_opmLEKNSt7complexIdEE", "cudaq::spin_op::operator*="], [2, 3, 1, "_CPPv4N5cudaq7spin_opmLEKd", "cudaq::spin_op::operator*="], [2, 3, 1, "_CPPv4N5cudaq7spin_opmLERK7spin_op", "cudaq::spin_op::operator*="], [2, 4, 1, "_CPPv4N5cudaq7spin_opmLEKNSt7complexIdEE", "cudaq::spin_op::operator*=::v"], [2, 4, 1, "_CPPv4N5cudaq7spin_opmLEKd", "cudaq::spin_op::operator*=::v"], [2, 4, 1, "_CPPv4N5cudaq7spin_opmLERK7spin_op", "cudaq::spin_op::operator*=::v"], [2, 3, 1, "_CPPv4N5cudaq7spin_oppLERK7spin_op", "cudaq::spin_op::operator+="], [2, 4, 1, "_CPPv4N5cudaq7spin_oppLERK7spin_op", "cudaq::spin_op::operator+=::v"], [2, 3, 1, "_CPPv4N5cudaq7spin_opmIERK7spin_op", "cudaq::spin_op::operator-="], [2, 4, 1, "_CPPv4N5cudaq7spin_opmIERK7spin_op", "cudaq::spin_op::operator-=::v"], [2, 3, 1, "_CPPv4N5cudaq7spin_opaSERK7spin_op", "cudaq::spin_op::operator="], [2, 3, 1, "_CPPv4NK5cudaq7spin_opeqERK7spin_op", "cudaq::spin_op::operator=="], [2, 4, 1, "_CPPv4NK5cudaq7spin_opeqERK7spin_op", "cudaq::spin_op::operator==::v"], [2, 3, 1, "_CPPv4N5cudaq7spin_op6randomENSt6size_tENSt6size_tEj", "cudaq::spin_op::random"], [2, 4, 1, "_CPPv4N5cudaq7spin_op6randomENSt6size_tENSt6size_tEj", "cudaq::spin_op::random::nQubits"], [2, 4, 1, "_CPPv4N5cudaq7spin_op6randomENSt6size_tENSt6size_tEj", "cudaq::spin_op::random::nTerms"], [2, 4, 1, "_CPPv4N5cudaq7spin_op6randomENSt6size_tENSt6size_tEj", "cudaq::spin_op::random::seed"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opE5pauliKNSt6size_tENSt7complexIdEE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opENSt6size_tE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opERK12spin_op_termRKNSt7complexIdEE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opERK7spin_op", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt13unordered_mapI12spin_op_termNSt7complexIdEEEE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt4pairIK12spin_op_termNSt7complexIdEEEE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorI12spin_op_termEERKNSt6vectorINSt7complexIdEEEE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorIdEENSt6size_tE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opERNSt4pairIK12spin_op_termNSt7complexIdEEEE", "cudaq::spin_op::spin_op"], [2, 3, 1, "_CPPv4N5cudaq7spin_op7spin_opEv", "cudaq::spin_op::spin_op"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt13unordered_mapI12spin_op_termNSt7complexIdEEEE", "cudaq::spin_op::spin_op::_terms"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorI12spin_op_termEERKNSt6vectorINSt7complexIdEEEE", "cudaq::spin_op::spin_op::bsf"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opE5pauliKNSt6size_tENSt7complexIdEE", "cudaq::spin_op::spin_op::coeff"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERK12spin_op_termRKNSt7complexIdEE", "cudaq::spin_op::spin_op::coeff"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorI12spin_op_termEERKNSt6vectorINSt7complexIdEEEE", "cudaq::spin_op::spin_op::coeffs"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorIdEENSt6size_tE", "cudaq::spin_op::spin_op::data_rep"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opE5pauliKNSt6size_tENSt7complexIdEE", "cudaq::spin_op::spin_op::id"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorIdEENSt6size_tE", "cudaq::spin_op::spin_op::nQubits"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opENSt6size_tE", "cudaq::spin_op::spin_op::numQubits"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERK7spin_op", "cudaq::spin_op::spin_op::o"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERK12spin_op_termRKNSt7complexIdEE", "cudaq::spin_op::spin_op::term"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERKNSt4pairIK12spin_op_termNSt7complexIdEEEE", "cudaq::spin_op::spin_op::termData"], [2, 4, 1, "_CPPv4N5cudaq7spin_op7spin_opERNSt4pairIK12spin_op_termNSt7complexIdEEEE", "cudaq::spin_op::spin_op::termData"], [2, 0, 1, "_CPPv4N5cudaq7spin_op12spin_op_termE", "cudaq::spin_op::spin_op_term"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op9to_matrixEv", "cudaq::spin_op::to_matrix"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op16to_sparse_matrixEv", "cudaq::spin_op::to_sparse_matrix"], [2, 3, 1, "_CPPv4NK5cudaq7spin_op9to_stringEb", "cudaq::spin_op::to_string"], [2, 4, 1, "_CPPv4NK5cudaq7spin_op9to_stringEb", "cudaq::spin_op::to_string::printCoefficients"], [2, 3, 1, "_CPPv4N5cudaq7spin_opD0Ev", "cudaq::spin_op::~spin_op"], [2, 1, 1, "_CPPv4N5cudaq5stateE", "cudaq::state"], [2, 3, 1, "_CPPv4N5cudaq5state9amplitudeERKNSt6vectorIiEE", "cudaq::state::amplitude"], [2, 4, 1, "_CPPv4N5cudaq5state9amplitudeERKNSt6vectorIiEE", "cudaq::state::amplitude::basisState"], [2, 3, 1, "_CPPv4N5cudaq5state10amplitudesERKNSt6vectorINSt6vectorIiEEEE", "cudaq::state::amplitudes"], [2, 4, 1, "_CPPv4N5cudaq5state10amplitudesERKNSt6vectorINSt6vectorIiEEEE", "cudaq::state::amplitudes::basisStates"], [2, 3, 1, "_CPPv4NK5cudaq5state4dumpERNSt7ostreamE", "cudaq::state::dump"], [2, 3, 1, "_CPPv4NK5cudaq5state4dumpEv", "cudaq::state::dump"], [2, 4, 1, "_CPPv4NK5cudaq5state4dumpERNSt7ostreamE", "cudaq::state::dump::os"], [2, 3, 1, "_CPPv4N5cudaq5state9from_dataERK10state_data", "cudaq::state::from_data"], [2, 4, 1, "_CPPv4N5cudaq5state9from_dataERK10state_data", "cudaq::state::from_data::data"], [2, 3, 1, "_CPPv4NK5cudaq5state14get_num_qubitsEv", "cudaq::state::get_num_qubits"], [2, 3, 1, "_CPPv4NK5cudaq5state15get_num_tensorsEv", "cudaq::state::get_num_tensors"], [2, 3, 1, "_CPPv4NK5cudaq5state13get_precisionEv", "cudaq::state::get_precision"], [2, 3, 1, "_CPPv4NK5cudaq5state10get_tensorENSt6size_tE", "cudaq::state::get_tensor"], [2, 4, 1, "_CPPv4NK5cudaq5state10get_tensorENSt6size_tE", "cudaq::state::get_tensor::tensorIdx"], [2, 3, 1, "_CPPv4NK5cudaq5state11get_tensorsEv", "cudaq::state::get_tensors"], [2, 3, 1, "_CPPv4NK5cudaq5state9is_on_gpuEv", "cudaq::state::is_on_gpu"], [2, 3, 1, "_CPPv4N5cudaq5stateclENSt6size_tENSt6size_tE", "cudaq::state::operator()"], [2, 3, 1, "_CPPv4N5cudaq5stateclERKNSt16initializer_listINSt6size_tEEENSt6size_tE", "cudaq::state::operator()"], [2, 4, 1, "_CPPv4N5cudaq5stateclENSt6size_tENSt6size_tE", "cudaq::state::operator()::idx"], [2, 4, 1, "_CPPv4N5cudaq5stateclENSt6size_tENSt6size_tE", "cudaq::state::operator()::jdx"], [2, 4, 1, "_CPPv4N5cudaq5stateclERKNSt16initializer_listINSt6size_tEEENSt6size_tE", "cudaq::state::operator()::tensorIdx"], [2, 3, 1, "_CPPv4N5cudaq5stateaSERR5state", "cudaq::state::operator="], [2, 4, 1, "_CPPv4N5cudaq5stateaSERR5state", "cudaq::state::operator=::other"], [2, 3, 1, "_CPPv4N5cudaq5stateixENSt6size_tE", "cudaq::state::operator[]"], [2, 4, 1, "_CPPv4N5cudaq5stateixENSt6size_tE", "cudaq::state::operator[]::idx"], [2, 3, 1, "_CPPv4N5cudaq5state7overlapERK5state", "cudaq::state::overlap"], [2, 4, 1, "_CPPv4N5cudaq5state7overlapERK5state", "cudaq::state::overlap::other"], [2, 3, 1, "_CPPv4N5cudaq5state5stateEP15SimulationState", "cudaq::state::state"], [2, 3, 1, "_CPPv4N5cudaq5state5stateERK5state", "cudaq::state::state"], [2, 4, 1, "_CPPv4N5cudaq5state5stateERK5state", "cudaq::state::state::other"], [2, 4, 1, "_CPPv4N5cudaq5state5stateEP15SimulationState", "cudaq::state::state::ptrToOwn"], [2, 3, 1, "_CPPv4I0ENK5cudaq5state7to_hostEvPNSt7complexI10ScalarTypeEENSt6size_tE", "cudaq::state::to_host"], [2, 2, 1, "_CPPv4I0ENK5cudaq5state7to_hostEvPNSt7complexI10ScalarTypeEENSt6size_tE", "cudaq::state::to_host::ScalarType"], [2, 4, 1, "_CPPv4I0ENK5cudaq5state7to_hostEvPNSt7complexI10ScalarTypeEENSt6size_tE", "cudaq::state::to_host::hostPtr"], [2, 4, 1, "_CPPv4I0ENK5cudaq5state7to_hostEvPNSt7complexI10ScalarTypeEENSt6size_tE", "cudaq::state::to_host::numElements"], [2, 0, 1, "_CPPv4N5cudaq10state_dataE", "cudaq::state_data"], [2, 0, 1, "_CPPv4N5cudaq6tensorE", "cudaq::tensor"], [2, 3, 1, "_CPPv4N5cudaq11unset_noiseEv", "cudaq::unset_noise"], [2, 1, 1, "_CPPv4N5nvqir18MPSSimulationStateE", "nvqir::MPSSimulationState"], [2, 1, 1, "_CPPv4N5nvqir24TensorNetSimulationStateE", "nvqir::TensorNetSimulationState"], [3, 8, 0, "-", "cudaq"]], "cudaq": [[3, 9, 1, "", "AmplitudeDampingChannel"], [3, 9, 1, "", "AsyncObserveResult"], [3, 9, 1, "", "AsyncSampleResult"], [3, 9, 1, "", "AsyncStateResult"], [3, 9, 1, "", "BitFlipChannel"], [3, 9, 1, "", "ComplexMatrix"], [3, 9, 1, "", "DepolarizationChannel"], [3, 11, 1, "", "Kernel"], [3, 9, 1, "", "KrausChannel"], [3, 9, 1, "", "KrausOperator"], [3, 9, 1, "", "NoiseModel"], [3, 9, 1, "", "ObserveResult"], [3, 9, 1, "", "OptimizationResult"], [3, 9, 1, "", "PhaseFlipChannel"], [3, 9, 1, "", "PyKernel"], [3, 9, 1, "", "PyKernelDecorator"], [3, 9, 1, "", "QuakeValue"], [3, 9, 1, "", "SampleResult"], [3, 9, 1, "", "SimulationPrecision"], [3, 9, 1, "", "SpinOperator"], [3, 9, 1, "", "State"], [3, 9, 1, "", "Target"], [3, 9, 1, "", "Tensor"], [3, 13, 1, "", "draw"], [3, 13, 1, "", "get_state"], [3, 13, 1, "", "get_state_async"], [3, 13, 1, "", "get_target"], [3, 13, 1, "", "get_targets"], [3, 13, 1, "", "has_target"], [3, 10, 1, "", "initialize_cudaq"], [3, 13, 1, "", "kernel"], [3, 13, 1, "", "make_kernel"], [3, 10, 1, "", "num_available_gpus"], [3, 13, 1, "", "observe"], [3, 13, 1, "", "observe_async"], [3, 11, 1, "", "qreg"], [3, 9, 1, "", "qubit"], [3, 9, 1, "", "qvector"], [3, 13, 1, "", "reset_target"], [3, 13, 1, "", "sample"], [3, 13, 1, "", "sample_async"], [3, 13, 1, "", "set_noise"], [3, 10, 1, "", "set_random_seed"], [3, 13, 1, "", "set_target"], [3, 13, 1, "", "translate"], [3, 13, 1, "", "unset_noise"], [3, 13, 1, "", "vqe"]], "cudaq.AmplitudeDampingChannel": [[3, 10, 1, "", "__init__"]], "cudaq.AsyncObserveResult": [[3, 10, 1, "", "get"]], "cudaq.AsyncSampleResult": [[3, 10, 1, "", "get"]], "cudaq.AsyncStateResult": [[3, 10, 1, "", "get"]], "cudaq.BitFlipChannel": [[3, 10, 1, "", "__init__"]], "cudaq.ComplexMatrix": [[3, 10, 1, "", "__getitem__"], [3, 10, 1, "", "__str__"], [3, 10, 1, "", "minimal_eigenvalue"]], "cudaq.DepolarizationChannel": [[3, 10, 1, "", "__init__"]], "cudaq.KrausChannel": [[3, 10, 1, "", "__getitem__"], [3, 10, 1, "", "append"]], "cudaq.KrausOperator": [[3, 12, 1, "", "col_count"], [3, 12, 1, "", "row_count"]], "cudaq.NoiseModel": [[3, 10, 1, "", "__init__"], [3, 10, 1, "", "add_channel"], [3, 10, 1, "", "get_channels"]], "cudaq.ObserveResult": [[3, 10, 1, "", "counts"], [3, 10, 1, "", "dump"], [3, 10, 1, "", "expectation"], [3, 10, 1, "", "expectation_z"], [3, 10, 1, "", "get_spin"]], "cudaq.PhaseFlipChannel": [[3, 10, 1, "", "__init__"]], "cudaq.PyKernel": [[3, 11, 1, "", "argument_count"], [3, 11, 1, "", "arguments"], [3, 11, 1, "", "name"]], "cudaq.PyKernelDecorator": [[3, 10, 1, "", "__call__"], [3, 10, 1, "", "__str__"], [3, 10, 1, "", "compile"], [3, 10, 1, "", "from_json"], [3, 10, 1, "", "to_json"], [3, 10, 1, "", "type_to_str"]], "cudaq.QuakeValue": [[3, 10, 1, "", "__add__"], [3, 10, 1, "", "__getitem__"], [3, 10, 1, "", "__mul__"], [3, 10, 1, "", "__neg__"], [3, 10, 1, "", "__radd__"], [3, 10, 1, "", "__rmul__"], [3, 10, 1, "", "__rsub__"], [3, 10, 1, "", "__sub__"], [3, 10, 1, "", "slice"]], "cudaq.SampleResult": [[3, 10, 1, "", "__getitem__"], [3, 10, 1, "", "__iter__"], [3, 10, 1, "", "__len__"], [3, 10, 1, "", "clear"], [3, 10, 1, "", "count"], [3, 10, 1, "", "dump"], [3, 10, 1, "", "expectation"], [3, 10, 1, "", "expectation_z"], [3, 10, 1, "", "get_marginal_counts"], [3, 10, 1, "", "get_register_counts"], [3, 10, 1, "", "get_sequential_data"], [3, 10, 1, "", "items"], [3, 10, 1, "", "most_probable"], [3, 10, 1, "", "probability"], [3, 11, 1, "", "register_names"], [3, 10, 1, "", "values"]], "cudaq.SimulationPrecision": [[3, 12, 1, "", "name"]], "cudaq.SpinOperator": [[3, 10, 1, "", "__add__"], [3, 10, 1, "", "__eq__"], [3, 10, 1, "", "__iter__"], [3, 10, 1, "", "__mul__"], [3, 10, 1, "", "__radd__"], [3, 10, 1, "", "__rmul__"], [3, 10, 1, "", "__rsub__"], [3, 10, 1, "", "__sub__"], [3, 10, 1, "", "distribute_terms"], [3, 10, 1, "", "dump"], [3, 10, 1, "", "for_each_pauli"], [3, 10, 1, "", "for_each_term"], [3, 10, 1, "", "from_json"], [3, 10, 1, "", "from_word"], [3, 10, 1, "", "get_coefficient"], [3, 10, 1, "", "get_qubit_count"], [3, 10, 1, "", "get_raw_data"], [3, 10, 1, "", "get_term_count"], [3, 10, 1, "", "is_identity"], [3, 10, 1, "", "random"], [3, 10, 1, "", "serialize"], [3, 10, 1, "", "to_json"], [3, 10, 1, "", "to_matrix"], [3, 10, 1, "", "to_sparse_matrix"], [3, 10, 1, "", "to_string"]], "cudaq.State": [[3, 10, 1, "", "amplitude"], [3, 10, 1, "", "amplitudes"], [3, 10, 1, "", "dump"], [3, 10, 1, "", "from_data"], [3, 10, 1, "", "getTensor"], [3, 10, 1, "", "getTensors"], [3, 10, 1, "", "is_on_gpu"], [3, 10, 1, "", "num_qubits"], [3, 10, 1, "", "overlap"]], "cudaq.Target": [[3, 12, 1, "", "description"], [3, 10, 1, "", "get_precision"], [3, 10, 1, "", "is_emulated"], [3, 10, 1, "", "is_remote"], [3, 12, 1, "", "name"], [3, 10, 1, "", "num_qpus"], [3, 12, 1, "", "platform"], [3, 12, 1, "", "simulator"]], "cudaq.gradients": [[3, 9, 1, "", "CentralDifference"], [3, 9, 1, "", "ForwardDifference"], [3, 9, 1, "", "ParameterShift"], [3, 9, 1, "", "gradient"]], "cudaq.gradients.CentralDifference": [[3, 10, 1, "", "compute"], [3, 10, 1, "", "from_json"], [3, 10, 1, "", "to_json"]], "cudaq.gradients.ForwardDifference": [[3, 10, 1, "", "compute"], [3, 10, 1, "", "from_json"], [3, 10, 1, "", "to_json"]], "cudaq.gradients.ParameterShift": [[3, 10, 1, "", "compute"], [3, 10, 1, "", "from_json"], [3, 10, 1, "", "to_json"]], "cudaq.mpi": [[3, 10, 1, "", "all_gather"], [3, 10, 1, "", "broadcast"], [3, 10, 1, "", "finalize"], [3, 10, 1, "", "initialize"], [3, 10, 1, "", "is_initialized"], [3, 10, 1, "", "num_ranks"], [3, 10, 1, "", "rank"]], "cudaq.optimizers": [[3, 9, 1, "", "COBYLA"], [3, 9, 1, "", "GradientDescent"], [3, 9, 1, "", "LBFGS"], [3, 9, 1, "", "NelderMead"], [3, 9, 1, "", "optimizer"]], "cudaq.optimizers.COBYLA": [[3, 10, 1, "", "from_json"], [3, 12, 1, "", "initial_parameters"], [3, 12, 1, "", "lower_bounds"], [3, 12, 1, "", "max_iterations"], [3, 10, 1, "", "optimize"], [3, 10, 1, "", "requires_gradients"], [3, 10, 1, "", "to_json"], [3, 12, 1, "", "upper_bounds"]], "cudaq.optimizers.GradientDescent": [[3, 10, 1, "", "from_json"], [3, 12, 1, "", "initial_parameters"], [3, 12, 1, "", "lower_bounds"], [3, 12, 1, "", "max_iterations"], [3, 10, 1, "", "optimize"], [3, 10, 1, "", "requires_gradients"], [3, 10, 1, "", "to_json"], [3, 12, 1, "", "upper_bounds"]], "cudaq.optimizers.LBFGS": [[3, 10, 1, "", "from_json"], [3, 12, 1, "", "initial_parameters"], [3, 12, 1, "", "lower_bounds"], [3, 12, 1, "", "max_iterations"], [3, 10, 1, "", "optimize"], [3, 10, 1, "", "requires_gradients"], [3, 10, 1, "", "to_json"], [3, 12, 1, "", "upper_bounds"]], "cudaq.optimizers.NelderMead": [[3, 10, 1, "", "from_json"], [3, 12, 1, "", "initial_parameters"], [3, 12, 1, "", "lower_bounds"], [3, 12, 1, "", "max_iterations"], [3, 10, 1, "", "optimize"], [3, 10, 1, "", "requires_gradients"], [3, 10, 1, "", "to_json"], [3, 12, 1, "", "upper_bounds"]], "cudaq.spin": [[3, 13, 1, "", "i"], [3, 13, 1, "", "x"], [3, 13, 1, "", "y"], [3, 13, 1, "", "z"]]}, "objtypes": {"0": "cpp:type", "1": "cpp:class", "2": "cpp:templateParam", "3": "cpp:function", "4": "cpp:functionParam", "5": "cpp:member", "6": "cpp:enum", "7": "cpp:enumerator", "8": "py:module", "9": "py:class", "10": "py:method", "11": "py:attribute", "12": "py:property", "13": "py:function"}, "objnames": {"0": ["cpp", "type", "C++ type"], "1": ["cpp", "class", "C++ class"], "2": ["cpp", "templateParam", "C++ template parameter"], "3": ["cpp", "function", "C++ function"], "4": ["cpp", "functionParam", "C++ function parameter"], "5": ["cpp", "member", "C++ member"], "6": ["cpp", "enum", "C++ enum"], "7": ["cpp", "enumerator", "C++ enumerator"], "8": ["py", "module", "Python module"], "9": ["py", "class", "Python class"], "10": ["py", "method", "Python method"], "11": ["py", "attribute", "Python attribute"], "12": ["py", "property", "Python property"], "13": ["py", "function", "Python function"]}, "titleterms": {"code": [0, 63], "document": 0, "cuda": [0, 2, 3, 4, 15, 17, 18, 19, 20, 35, 36, 39, 40, 41, 42, 43, 47, 57, 58, 59, 60, 61, 63, 64, 65, 67, 68, 69, 70], "q": [0, 2, 3, 4, 15, 17, 18, 19, 20, 35, 36, 39, 40, 41, 42, 43, 47, 57, 58, 59, 60, 61, 63, 64, 65, 67, 68, 69, 70], "api": [0, 2, 3], "quantum": [1, 2, 4, 6, 8, 12, 15, 20, 23, 24, 27, 28, 29, 30, 32, 37, 38, 49, 54, 55, 56], "oper": [1, 2, 27, 28], "unitari": 1, "qubit": [1, 7, 13, 14, 27, 32], "x": 1, "y": 1, "z": 1, "h": 1, "r1": 1, "rx": 1, "ry": 1, "rz": 1, "": [1, 6, 23, 60], "t": 1, "swap": 1, "u3": 1, "adjoint": 1, "control": [1, 21, 51], "measur": [1, 55], "mz": 1, "mx": 1, "my": 1, "user": 1, "defin": 1, "custom": 1, "c": [2, 7, 36, 61, 67], "common": [2, 29], "nois": [2, 13], "model": [2, 13, 25], "kernel": [2, 3, 14, 22, 24, 38, 42], "builder": 2, "algorithm": [2, 6, 7, 20, 23, 54], "platform": [2, 30, 38], "util": 2, "namespac": [2, 26], "python": [3, 36, 61, 63], "program": [3, 23, 29, 41, 43], "construct": 3, "execut": [3, 37], "backend": [3, 35, 36, 37, 39], "configur": 3, "data": [3, 4], "type": [3, 32], "optim": [3, 15, 20, 54], "gradient": [3, 20], "noisi": [3, 10, 53], "simul": [3, 4, 10, 16, 37, 38, 39, 44, 46, 53, 60, 63], "mpi": [3, 61, 63], "submodul": 3, "divis": 4, "cluster": 4, "With": 4, "coreset": 4, "us": [4, 7, 15, 32, 49, 63, 65], "preprocess": 4, "function": [4, 20], "qaoa": [4, 9, 11], "implement": 4, "scale": 4, "cost": 5, "minim": 5, "deutsch": 6, "xor": 6, "oplu": 6, "oracl": 6, "phase": [6, 23], "parallel": [6, 38, 48, 52], "hadamard": 7, "test": 7, "A": [7, 16], "numer": 7, "result": 7, "refer": [7, 16], "b": [7, 16], "sampl": [7, 20, 23, 43], "primit": [7, 20], "ancilla": 7, "comput": [7, 29, 36, 48, 49, 55, 63], "expect": [7, 48], "valu": [7, 48], "multi": [7, 38, 39, 51, 52], "gpu": [7, 16, 37, 39, 43, 52, 63], "matrix": [7, 13, 39], "element": 7, "diagon": 7, "exampl": [7, 23, 47], "numpi": 7, "cupi": 7, "In": [7, 63], "thi": [7, 60], "sinc": 7, "we": 7, "ar": 7, "have": 7, "2x2": 7, "hybrid": 8, "neural": 8, "network": [8, 39], "molecular": 9, "dock": 9, "via": [9, 63], "dc": 9, "max": 11, "cut": 11, "fourier": 12, "transform": 12, "revisit": 12, "readout": 13, "error": 13, "mitig": 13, "invers": 13, "confus": 13, "from": [13, 36, 61, 67], "singl": [13, 39], "k": 13, "local": [13, 63], "matric": 13, "full": 13, "visual": 14, "variat": [15, 56], "eigensolv": [15, 56], "integr": [15, 66, 67], "third": [15, 67], "parti": [15, 67], "water": 16, "molecul": 16, "activ": 16, "space": 16, "cpu": [16, 39], "v": [16, 63], "classic": 16, "ccsd": 16, "vqe": 16, "uccsd": 16, "content": [17, 40, 62], "releas": 18, "languag": 19, "specif": [19, 33], "cudaq": [20, 27, 28, 32], "observ": [20, 43], "deprec": [20, 32], "move": 20, "librari": [20, 61, 67], "flow": 21, "just": 22, "time": 22, "creation": 22, "hello": 23, "world": 23, "simpl": 23, "bell": 23, "state": [23, 38, 39, 55], "ghz": 23, "prepar": 23, "estim": 23, "deuteron": 23, "bind": 23, "energi": 23, "paramet": 23, "sweep": 23, "grover": 23, "iter": 23, "machin": 25, "standard": 26, "intrins": 27, "spin_op": 28, "pattern": 29, "action": [29, 60], "uncomput": 29, "sub": 31, "circuit": [31, 52, 60], "synthesi": [31, 51], "qudit": 32, "level": 32, "contain": [32, 63], "qview": 32, "2": 32, "qvector": 32, "qarrai": 32, "n": 32, "qspan": 32, "instead": 32, "qreg": 32, "quak": 34, "dialect": 34, "gener": 34, "introduct": [34, 50, 63], "motiv": 34, "target": [35, 52], "hardwar": [36, 49], "ionq": [36, 49], "set": 36, "credenti": 36, "submiss": 36, "iqm": [36, 49], "oqc": [36, 49], "orca": [36, 49], "quantinuum": [36, 49], "nvidia": [37, 38], "cloud": [37, 63], "quick": [37, 68], "start": [37, 63, 68], "select": 37, "multipl": [37, 48, 52], "qpu": 37, "asynchron": 37, "faq": 37, "processor": [38, 48, 52], "mqpu": 38, "distribut": [38, 63], "mode": [38, 39], "remot": [38, 63], "support": [38, 39, 61, 63], "argument": 38, "serial": 38, "access": [38, 63], "vector": 39, "featur": 39, "environ": 39, "variabl": 39, "option": 39, "node": 39, "addit": [39, 63], "openmp": 39, "onli": 39, "tensor": 39, "product": 39, "default": 39, "basic": 40, "build": [41, 61], "your": [41, 43, 59, 68], "first": [41, 43], "what": 42, "i": 42, "run": 43, "troubleshoot": 44, "debug": 44, "verbos": 44, "output": 44, "bernstein": 45, "vazirani": 45, "cuquantum": 46, "across": [48, 52], "provid": 49, "workflow": 52, "avail": 52, "batch": 52, "hamiltonian": 52, "term": 52, "approxim": 54, "101": 55, "gate": 55, "work": 57, "ir": 57, "extend": [58, 60], "creat": 59, "own": 59, "compil": [59, 67], "pass": 59, "new": 60, "circuitsimul": 60, "requir": [60, 63], "subtyp": 60, "method": 60, "overrid": 60, "let": 60, "see": 60, "instal": [61, 62, 63, 68], "sourc": 61, "prerequisit": 61, "depend": [61, 63], "toolchain": [61, 67], "host": [61, 63], "runtim": 61, "guid": 62, "docker": 63, "singular": 63, "wheel": 63, "pre": 63, "built": 63, "binari": [63, 67], "develop": 63, "connect": 63, "tunnel": 63, "ssh": 63, "dgx": 63, "get": 63, "jupyterlab": 63, "tool": [63, 66], "pypi": 63, "imag": 63, "updat": 63, "compat": 63, "system": 63, "next": 63, "step": 63, "cmake": 64, "project": 65, "other": 66, "softwar": 66, "call": 67, "an": 67, "interfac": 67, "between": 67, "differ": 67, "valid": 68, "tutori": 69, "version": 70}, "envversion": {"sphinx.domains.c": 2, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 8, "sphinx.domains.index": 1, "sphinx.domains.javascript": 2, "sphinx.domains.math": 2, "sphinx.domains.python": 3, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.intersphinx": 1, "nbsphinx": 4, "sphinx": 57}, "alltitles": {"Quantum Operators": [[28, "quantum-operators"]], "cudaq::spin_op": [[28, "cudaq-spin-op"]], "Sub-circuit Synthesis": [[31, "sub-circuit-synthesis"]], "Common Quantum Programming Patterns": [[29, "common-quantum-programming-patterns"]], "Compute-Action-Uncompute": [[29, "compute-action-uncompute"]], "Namespace and Standard": [[26, "namespace-and-standard"]], "Machine Model": [[25, "machine-model"]], "Quantum Kernels": [[24, "quantum-kernels"]], "Quantum Platform": [[30, "quantum-platform"]], "Quantum Intrinsic Operations": [[27, "quantum-intrinsic-operations"]], "Operations on cudaq::qubit": [[27, "operations-on-cudaq-qubit"]], "CUDA-Q by Example": [[47, "cuda-q-by-example"]], "Troubleshooting": [[44, "troubleshooting"]], "Debugging and Verbose Simulation Output": [[44, "debugging-and-verbose-simulation-output"]], "What is a CUDA-Q kernel?": [[42, "what-is-a-cuda-q-kernel"]], "Running your first CUDA-Q Program": [[43, "running-your-first-cuda-q-program"]], "Sample": [[43, "sample"]], "Observe": [[43, "observe"]], "Running on a GPU": [[43, "running-on-a-gpu"]], "CUDA-Q Basics": [[40, "cuda-q-basics"]], "Contents": [[40, null], [62, null], [17, null]], "Building your first CUDA-Q Program": [[41, "building-your-first-cuda-q-program"]], "Bernstein-Vazirani": [[45, "bernstein-vazirani"]], "Simulations with cuQuantum": [[46, "simulations-with-cuquantum"]], "Quantum Computing 101": [[55, "quantum-computing-101"]], "Quantum States": [[55, "quantum-states"]], "Quantum Gates": [[55, "quantum-gates"]], "Measurements": [[55, "measurements"]], "Quantum Approximate Optimization Algorithm": [[54, "quantum-approximate-optimization-algorithm"]], "Multi-control Synthesis": [[51, "multi-control-synthesis"]], "Introduction": [[50, "introduction"], [63, "introduction"]], "Using Quantum Hardware Providers": [[49, "using-quantum-hardware-providers"]], "IonQ": [[49, "ionq"], [36, "ionq"]], "IQM": [[49, "iqm"], [36, "iqm"]], "OQC": [[49, "oqc"], [36, "oqc"]], "ORCA Computing": [[49, "orca-computing"], [36, "orca-computing"]], "Quantinuum": [[49, "quantinuum"], [36, "quantinuum"]], "Noisy Simulation": [[53, "noisy-simulation"], [10, "Noisy-Simulation"], [3, "noisy-simulation"]], "Computing Expectation Values": [[48, "computing-expectation-values"]], "Parallelizing across Multiple Processors": [[48, "parallelizing-across-multiple-processors"]], "Multi-GPU Workflows": [[52, "multi-gpu-workflows"]], "Available Targets": [[52, "available-targets"]], "Parallelization across Multiple Processors": [[52, "parallelization-across-multiple-processors"]], "Batching Hamiltonian Terms": [[52, "batching-hamiltonian-terms"]], "Circuit Batching": [[52, "circuit-batching"]], "Installation Guide": [[62, "installation-guide"]], "Create your own CUDA-Q Compiler Pass": [[59, "create-your-own-cuda-q-compiler-pass"]], "Variational Quantum Eigensolver": [[56, "variational-quantum-eigensolver"], [15, "Variational-Quantum-Eigensolver"]], "Extending CUDA-Q": [[58, "extending-cuda-q"]], "Local Installation": [[63, "local-installation"]], "Docker": [[63, "docker"]], "Singularity": [[63, "singularity"]], "Python wheels": [[63, "python-wheels"]], "Pre-built binaries": [[63, "pre-built-binaries"]], "Development with VS Code": [[63, "development-with-vs-code"]], "Using a Docker container": [[63, "using-a-docker-container"]], "Using a Singularity container": [[63, "using-a-singularity-container"]], "Connecting to a Remote Host": [[63, "connecting-to-a-remote-host"]], "Developing with Remote Tunnels": [[63, "developing-with-remote-tunnels"]], "Remote Access via SSH": [[63, "remote-access-via-ssh"]], "DGX Cloud": [[63, "dgx-cloud"]], "Get Started": [[63, "get-started"]], "Use JupyterLab": [[63, "use-jupyterlab"]], "Use VS Code": [[63, "use-vs-code"]], "Additional CUDA Tools": [[63, "additional-cuda-tools"]], "Installation via PyPI": [[63, "installation-via-pypi"]], "Installation In Container Images": [[63, "installation-in-container-images"]], "Installing Pre-built Binaries": [[63, "installing-pre-built-binaries"]], "Distributed Computing with MPI": [[63, "distributed-computing-with-mpi"]], "Updating CUDA-Q": [[63, "updating-cuda-q"]], "Dependencies and Compatibility": [[63, "dependencies-and-compatibility"]], "Supported Systems": [[63, "id10"]], "Requirements for GPU Simulation": [[63, "id11"]], "Next Steps": [[63, "next-steps"]], "Extending CUDA-Q with a new Simulator": [[60, "extending-cuda-q-with-a-new-simulator"]], "CircuitSimulator": [[60, "circuitsimulator"]], "Required Circuit Simulator Subtype Method Overrides": [[60, "id1"]], "Let\u2019s see this in action": [[60, "let-s-see-this-in-action"]], "Working with the CUDA-Q IR": [[57, "working-with-the-cuda-q-ir"]], "Installation from Source": [[61, "installation-from-source"]], "Prerequisites": [[61, "prerequisites"]], "Build Dependencies": [[61, "build-dependencies"]], "CUDA": [[61, "cuda"]], "Toolchain": [[61, "toolchain"]], "Building CUDA-Q": [[61, "building-cuda-q"]], "Python Support": [[61, "python-support"]], "C++ Support": [[61, "c-support"]], "Installation on the Host": [[61, "installation-on-the-host"]], "CUDA Runtime Libraries": [[61, "cuda-runtime-libraries"]], "MPI": [[61, "mpi"]], "CUDA-Q Simulation Backends": [[39, "cuda-q-simulation-backends"]], "State Vector Simulators": [[39, "state-vector-simulators"]], "Features": [[39, "features"]], "Single-GPU": [[39, "single-gpu"]], "Environment variable options supported in single-GPU mode": [[39, "id4"]], "Multi-node multi-GPU": [[39, "multi-node-multi-gpu"], [39, "id2"]], "Additional environment variable options for multi-node multi-GPU mode": [[39, "id5"]], "OpenMP CPU-only": [[39, "openmp-cpu-only"]], "Tensor Network Simulators": [[39, "tensor-network-simulators"]], "Matrix product state": [[39, "matrix-product-state"]], "Default Simulator": [[39, "default-simulator"]], "CUDA-Q Backends": [[35, "cuda-q-backends"]], "Backend Targets": [[35, null]], "Quake Dialect": [[34, "quake-dialect"]], "General Introduction": [[34, "general-introduction"]], "Motivation": [[34, "motivation"]], "NVIDIA Quantum Cloud": [[37, "nvidia-quantum-cloud"]], "Quick Start": [[37, "quick-start"], [68, "quick-start"]], "Simulator Backend Selection": [[37, "simulator-backend-selection"]], "Multiple GPUs": [[37, "multiple-gpus"]], "Simulator Backends": [[37, "id1"]], "Multiple QPUs Asynchronous Execution": [[37, "multiple-qpus-asynchronous-execution"]], "FAQ": [[37, "faq"]], "Specifications": [[33, "specifications"]], "Multi-Processor Platforms": [[38, "multi-processor-platforms"]], "NVIDIA MQPU Platform": [[38, "nvidia-mqpu-platform"]], "Parallel distribution mode": [[38, "parallel-distribution-mode"]], "Remote MQPU Platform": [[38, "remote-mqpu-platform"]], "Supported Kernel Arguments": [[38, "supported-kernel-arguments"]], "Kernel argument serialization": [[38, "id4"]], "Accessing Simulated Quantum State": [[38, "accessing-simulated-quantum-state"]], "CUDA-Q Hardware Backends": [[36, "cuda-q-hardware-backends"]], "Setting Credentials": [[36, "setting-credentials"], [36, "id1"], [36, "id4"], [36, "id7"], [36, "quantinuum-backend"]], "Submission from C++": [[36, "submission-from-c"], [36, "id2"], [36, "id5"], [36, "id8"], [36, "id11"]], "Submission from Python": [[36, "submission-from-python"], [36, "id3"], [36, "id6"], [36, "id9"], [36, "id12"]], "Quantum Types": [[32, "quantum-types"]], "cudaq::qudit": [[32, "cudaq-qudit-levels"]], "cudaq::qubit": [[32, "cudaq-qubit"]], "Quantum Containers": [[32, "quantum-containers"]], "cudaq::qview": [[32, "cudaq-qview-levels-2"]], "cudaq::qvector": [[32, "cudaq-qvector-levels-2"]], "cudaq::qarray": [[32, "cudaq-qarray-n-levels-2"]], "cudaq::qspan (Deprecated. Use cudaq::qview instead.)": [[32, "cudaq-qspan-n-levels-deprecated-use-cudaq-qview-levels-instead"]], "cudaq::qreg (Deprecated. Use cudaq::qvector instead.)": [[32, "cudaq-qreg-n-levels-deprecated-use-cudaq-qvector-levels-instead"]], "CUDA-Q and CMake": [[64, "cuda-q-and-cmake"]], "CUDA-Q Tutorials": [[69, "cuda-q-tutorials"]], "CUDA-Q Versions": [[70, "cuda-q-versions"]], "Install CUDA-Q": [[68, "install-cuda-q"]], "Validate your Installation": [[68, "validate-your-installation"]], "Integrating with Third-Party Libraries": [[67, "integrating-with-third-party-libraries"]], "Calling a CUDA-Q library from C++": [[67, "calling-a-cuda-q-library-from-c"]], "Calling an C++ library from CUDA-Q": [[67, "calling-an-c-library-from-cuda-q"]], "Interfacing between binaries compiled with a different toolchains": [[67, "interfacing-between-binaries-compiled-with-a-different-toolchains"]], "Using CUDA and CUDA-Q in a Project": [[65, "using-cuda-and-cuda-q-in-a-project"]], "Integration with other Software Tools": [[66, "integration-with-other-software-tools"]], "Example Programs": [[23, "example-programs"]], "Hello World - Simple Bell State": [[23, "hello-world-simple-bell-state"]], "GHZ State Preparation and Sampling": [[23, "ghz-state-preparation-and-sampling"]], "Quantum Phase Estimation": [[23, "quantum-phase-estimation"]], "Deuteron Binding Energy Parameter Sweep": [[23, "deuteron-binding-energy-parameter-sweep"]], "Grover\u2019s Algorithm": [[23, "grover-s-algorithm"]], "Iterative Phase Estimation": [[23, "iterative-phase-estimation"]], "Quantum Algorithmic Primitives": [[20, "quantum-algorithmic-primitives"]], "cudaq::sample": [[20, "cudaq-sample"]], "cudaq::observe": [[20, "cudaq-observe"]], "cudaq::optimizer (deprecated, functionality moved to CUDA-Q libraries)": [[20, "cudaq-optimizer-deprecated-functionality-moved-to-cuda-q-libraries"]], "cudaq::gradient (deprecated, functionality moved to CUDA-Q libraries)": [[20, "cudaq-gradient-deprecated-functionality-moved-to-cuda-q-libraries"]], "Just-in-Time Kernel Creation": [[22, "just-in-time-kernel-creation"]], "CUDA-Q Releases": [[18, "cuda-q-releases"]], "CUDA-Q": [[17, "cuda-q"], [19, null]], "Language Specification": [[19, "language-specification"]], "Control Flow": [[21, "control-flow"]], "Water Molecule with Active Space (CPU vs. GPU)": [[16, "Water-Molecule-with-Active-Space-(CPU-vs.-GPU)"]], "A- Classical simulation as a reference: CCSD": [[16, "A--Classical-simulation-as-a-reference:-CCSD"]], "B- VQE-UCCSD:": [[16, "B--VQE-UCCSD:"]], "Molecular docking via DC-QAOA": [[9, "Molecular-docking-via-DC-QAOA"]], "Readout Error Mitigation": [[13, "Readout-Error-Mitigation"]], "Inverse confusion matrix from single-qubit noise model": [[13, "Inverse-confusion-matrix-from-single-qubit-noise-model"]], "Inverse confusion matrix from k local confusion matrices": [[13, "Inverse-confusion-matrix-from-k-local-confusion-matrices"]], "Inverse of full confusion matrix": [[13, "Inverse-of-full-confusion-matrix"]], "Quantum Fourier Transform": [[12, "Quantum-Fourier-Transform"]], "Quantum Fourier Transform revisited": [[12, "Quantum-Fourier-Transform-revisited"]], "Visualization": [[14, "Visualization"]], "Qubit Visualization": [[14, "Qubit-Visualization"]], "Kernel Visualization": [[14, "Kernel-Visualization"]], "Using CUDA-Q Optimizers": [[15, "Using-CUDA-Q-Optimizers"]], "Integration with Third-Party Optimizers": [[15, "Integration-with-Third-Party-Optimizers"]], "Max-Cut with QAOA": [[11, "Max-Cut-with-QAOA"]], "Hybrid Quantum Neural Networks": [[8, "Hybrid-Quantum-Neural-Networks"]], "Deutsch\u2019s Algorithm": [[6, "Deutsch's-Algorithm"]], "XOR \\oplus": [[6, "XOR-\\oplus"]], "Quantum oracles": [[6, "Quantum-oracles"]], "Phase oracle": [[6, "Phase-oracle"]], "Quantum parallelism": [[6, "Quantum-parallelism"]], "Deutschs\u2019 Algorithm:": [[6, "Deutschs'-Algorithm:"]], "CUDA-Q C++ API": [[2, "cuda-q-c-api"]], "Operators": [[2, "operators"]], "Quantum": [[2, "quantum"]], "Common": [[2, "common"]], "Noise Modeling": [[2, "noise-modeling"]], "Kernel Builder": [[2, "kernel-builder"]], "Algorithms": [[2, "algorithms"]], "Platform": [[2, "platform"]], "Utilities": [[2, "utilities"]], "Namespaces": [[2, "namespaces"]], "Hadamard Test": [[7, "Hadamard-Test"]], "A- Numerical result as a reference:": [[7, "A--Numerical-result-as-a-reference:"]], "B- Using sample algorithmic primitive to sample the ancilla qubit and compute the expectation value.": [[7, "B--Using-sample-algorithmic-primitive-to-sample-the-ancilla-qubit-and-compute-the-expectation-value."]], "C- Use multi-GPUs to compute the matrix elements": [[7, "C--Use-multi-GPUs-to-compute-the-matrix-elements"]], "Diagonalize the matrix using for example Numpy or CuPy. In this example, since we are having 2x2 matrix, we use numpy.": [[7, "Diagonalize-the-matrix-using-for-example-Numpy-or-CuPy.-In-this-example,-since-we-are-having-2x2-matrix,-we-use-numpy."]], "Quantum Operations": [[1, "quantum-operations"]], "Unitary Operations on Qubits": [[1, "unitary-operations-on-qubits"]], "x": [[1, "x"]], "y": [[1, "y"]], "z": [[1, "z"]], "h": [[1, "h"]], "r1": [[1, "r1"]], "rx": [[1, "rx"]], "ry": [[1, "ry"]], "rz": [[1, "rz"]], "s": [[1, "s"]], "t": [[1, "t"]], "swap": [[1, "swap"]], "u3": [[1, "u3"]], "Adjoint and Controlled Operations": [[1, "adjoint-and-controlled-operations"]], "Measurements on Qubits": [[1, "measurements-on-qubits"]], "mz": [[1, "mz"]], "mx": [[1, "mx"]], "my": [[1, "my"]], "User-Defined Custom Operations": [[1, "user-defined-custom-operations"]], "Cost Minimization": [[5, "Cost-Minimization"]], "CUDA-Q Python API": [[3, "module-cudaq"]], "Program Construction": [[3, "program-construction"]], "Kernel Execution": [[3, "kernel-execution"]], "Backend Configuration": [[3, "backend-configuration"]], "Data Types": [[3, "data-types"]], "Optimizers": [[3, "optimizers"]], "Gradients": [[3, "gradients"]], "MPI Submodule": [[3, "mpi-submodule"]], "Divisive Clustering With Coresets Using CUDA-Q": [[4, "Divisive-Clustering-With-Coresets-Using-CUDA-Q"]], "Data preprocessing": [[4, "Data-preprocessing"]], "Quantum functions": [[4, "Quantum-functions"]], "Divisive Clustering Function": [[4, "Divisive-Clustering-Function"]], "QAOA Implementation": [[4, "QAOA-Implementation"]], "Scaling simulations with CUDA-Q": [[4, "Scaling-simulations-with-CUDA-Q"]], "Code documentation": [[0, "code-documentation"]], "CUDA-Q API": [[0, null]]}, "indexentries": {"cudaq (c++ type)": [[2, "_CPPv45cudaq"]], "cudaq::basenvcfsimulatorqpu (c++ class)": [[2, "_CPPv4N5cudaq20BaseNvcfSimulatorQPUE"]], "cudaq::baseremoterestqpu (c++ class)": [[2, "_CPPv4N5cudaq17BaseRemoteRESTQPUE"]], "cudaq::baseremotesimulatorqpu (c++ class)": [[2, "_CPPv4N5cudaq22BaseRemoteSimulatorQPUE"]], "cudaq::cusvstate (c++ class)": [[2, "_CPPv4I0EN5cudaq9CusvStateE"]], "cudaq::executioncontext (c++ class)": [[2, "_CPPv4N5cudaq16ExecutionContextE"]], "cudaq::executioncontext::executioncontext (c++ function)": [[2, "_CPPv4N5cudaq16ExecutionContext16ExecutionContextEKNSt6stringE"], [2, "_CPPv4N5cudaq16ExecutionContext16ExecutionContextEKNSt6stringENSt6size_tE"]], "cudaq::executioncontext::amplitudemaps (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext13amplitudeMapsE"]], "cudaq::executioncontext::asyncexec (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext9asyncExecE"]], "cudaq::executioncontext::batchiteration (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext14batchIterationE"]], "cudaq::executioncontext::canhandleobserve (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext16canHandleObserveE"]], "cudaq::executioncontext::expectationvalue (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext16expectationValueE"]], "cudaq::executioncontext::futureresult (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext12futureResultE"]], "cudaq::executioncontext::hasconditionalsonmeasureresults (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext31hasConditionalsOnMeasureResultsE"]], "cudaq::executioncontext::invocationresultbuffer (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext22invocationResultBufferE"]], "cudaq::executioncontext::kernelname (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext10kernelNameE"]], "cudaq::executioncontext::kerneltrace (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext11kernelTraceE"]], "cudaq::executioncontext::name (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext4nameE"]], "cudaq::executioncontext::noisemodel (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext10noiseModelE"]], "cudaq::executioncontext::optresult (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext9optResultE"]], "cudaq::executioncontext::overlapcomputestates (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext20overlapComputeStatesE"]], "cudaq::executioncontext::overlapresult (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext13overlapResultE"]], "cudaq::executioncontext::registernames (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext13registerNamesE"]], "cudaq::executioncontext::reorderidx (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext10reorderIdxE"]], "cudaq::executioncontext::result (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext6resultE"]], "cudaq::executioncontext::shots (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext5shotsE"]], "cudaq::executioncontext::simulationstate (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext15simulationStateE"]], "cudaq::executioncontext::spin (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext4spinE"]], "cudaq::executioncontext::totaliterations (c++ member)": [[2, "_CPPv4N5cudaq16ExecutionContext15totalIterationsE"]], "cudaq::executionresult (c++ struct)": [[2, "_CPPv4N5cudaq15ExecutionResultE"]], "cudaq::executionresult::executionresult (c++ function)": [[2, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionary"], [2, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryNSt6stringE"], [2, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultE16CountsDictionaryd"], [2, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultENSt6stringE"], [2, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultERK15ExecutionResult"], [2, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultEd"], [2, "_CPPv4N5cudaq15ExecutionResult15ExecutionResultEv"]], "cudaq::executionresult::appendresult (c++ function)": [[2, "_CPPv4N5cudaq15ExecutionResult12appendResultENSt6stringENSt6size_tE"]], "cudaq::executionresult::deserialize (c++ function)": [[2, "_CPPv4N5cudaq15ExecutionResult11deserializeERNSt6vectorINSt6size_tEEE"]], "cudaq::executionresult::operator= (c++ function)": [[2, "_CPPv4N5cudaq15ExecutionResultaSERK15ExecutionResult"]], "cudaq::executionresult::operator== (c++ function)": [[2, "_CPPv4NK5cudaq15ExecutionResulteqERK15ExecutionResult"]], "cudaq::executionresult::registername (c++ member)": [[2, "_CPPv4N5cudaq15ExecutionResult12registerNameE"]], "cudaq::executionresult::sequentialdata (c++ member)": [[2, "_CPPv4N5cudaq15ExecutionResult14sequentialDataE"]], "cudaq::executionresult::serialize (c++ function)": [[2, "_CPPv4NK5cudaq15ExecutionResult9serializeEv"]], "cudaq::kernelexecutiontask (c++ type)": [[2, "_CPPv4N5cudaq19KernelExecutionTaskE"]], "cudaq::qpu (c++ class)": [[2, "_CPPv4N5cudaq3QPUE"]], "cudaq::qpu::qpu (c++ function)": [[2, "_CPPv4N5cudaq3QPU3QPUENSt6size_tE"], [2, "_CPPv4N5cudaq3QPU3QPUERR3QPU"], [2, "_CPPv4N5cudaq3QPU3QPUEv"]], "cudaq::qpu::enqueue (c++ function)": [[2, "_CPPv4N5cudaq3QPU7enqueueER11QuantumTask"]], "cudaq::qpu::getconnectivity (c++ function)": [[2, "_CPPv4N5cudaq3QPU15getConnectivityEv"]], "cudaq::qpu::getexecutionthreadid (c++ function)": [[2, "_CPPv4NK5cudaq3QPU20getExecutionThreadIdEv"]], "cudaq::qpu::getnumqubits (c++ function)": [[2, "_CPPv4N5cudaq3QPU12getNumQubitsEv"]], "cudaq::qpu::getremotecapabilities (c++ function)": [[2, "_CPPv4NK5cudaq3QPU21getRemoteCapabilitiesEv"]], "cudaq::qpu::isemulated (c++ function)": [[2, "_CPPv4N5cudaq3QPU10isEmulatedEv"]], "cudaq::qpu::issimulator (c++ function)": [[2, "_CPPv4N5cudaq3QPU11isSimulatorEv"]], "cudaq::qpu::launchkernel (c++ function)": [[2, "_CPPv4N5cudaq3QPU12launchKernelERKNSt6stringEPFvPvEPvNSt8uint64_tENSt8uint64_tE"]], "cudaq::qpu::launchserializedcodeexecution (c++ function)": [[2, "_CPPv4N5cudaq3QPU29launchSerializedCodeExecutionERKNSt6stringERN5cudaq30SerializedCodeExecutionContextE"]], "cudaq::qpu::onrandomseedset (c++ function)": [[2, "_CPPv4N5cudaq3QPU15onRandomSeedSetENSt6size_tE"]], "cudaq::qpu::resetexecutioncontext (c++ function)": [[2, "_CPPv4N5cudaq3QPU21resetExecutionContextEv"]], "cudaq::qpu::setexecutioncontext (c++ function)": [[2, "_CPPv4N5cudaq3QPU19setExecutionContextEP16ExecutionContext"]], "cudaq::qpu::setid (c++ function)": [[2, "_CPPv4N5cudaq3QPU5setIdENSt6size_tE"]], "cudaq::qpu::setshots (c++ function)": [[2, "_CPPv4N5cudaq3QPU8setShotsEi"]], "cudaq::qpu::supportsconditionalfeedback (c++ function)": [[2, "_CPPv4N5cudaq3QPU27supportsConditionalFeedbackEv"]], "cudaq::qpu::~qpu (c++ function)": [[2, "_CPPv4N5cudaq3QPUD0Ev"]], "cudaq::quakevalue (c++ class)": [[2, "_CPPv4N5cudaq10QuakeValueE"]], "cudaq::quakevalue::quakevalue (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEN4mlir5ValueE"], [2, "_CPPv4N5cudaq10QuakeValue10QuakeValueERN4mlir20ImplicitLocOpBuilderEd"]], "cudaq::quakevalue::canvalidatenumelements (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue22canValidateNumElementsEv"]], "cudaq::quakevalue::constantsize (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue12constantSizeEv"]], "cudaq::quakevalue::dump (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue4dumpERNSt7ostreamE"], [2, "_CPPv4N5cudaq10QuakeValue4dumpEv"]], "cudaq::quakevalue::getrequiredelements (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue19getRequiredElementsEv"]], "cudaq::quakevalue::getvalue (c++ function)": [[2, "_CPPv4NK5cudaq10QuakeValue8getValueEv"]], "cudaq::quakevalue::inverse (c++ function)": [[2, "_CPPv4NK5cudaq10QuakeValue7inverseEv"]], "cudaq::quakevalue::isstdvec (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue8isStdVecEv"]], "cudaq::quakevalue::operator* (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValuemlE10QuakeValue"], [2, "_CPPv4N5cudaq10QuakeValuemlEKd"]], "cudaq::quakevalue::operator+ (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValueplE10QuakeValue"], [2, "_CPPv4N5cudaq10QuakeValueplEKd"], [2, "_CPPv4N5cudaq10QuakeValueplEKi"]], "cudaq::quakevalue::operator- (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValuemiE10QuakeValue"], [2, "_CPPv4N5cudaq10QuakeValuemiEKd"], [2, "_CPPv4N5cudaq10QuakeValuemiEKi"], [2, "_CPPv4NK5cudaq10QuakeValuemiEv"]], "cudaq::quakevalue::operator/ (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValuedvE10QuakeValue"], [2, "_CPPv4N5cudaq10QuakeValuedvEKd"]], "cudaq::quakevalue::operator[] (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValueixEKNSt6size_tE"], [2, "_CPPv4N5cudaq10QuakeValueixERK10QuakeValue"]], "cudaq::quakevalue::size (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue4sizeEv"]], "cudaq::quakevalue::slice (c++ function)": [[2, "_CPPv4N5cudaq10QuakeValue5sliceEKNSt6size_tEKNSt6size_tE"]], "cudaq::quantumtask (c++ type)": [[2, "_CPPv4N5cudaq11QuantumTaskE"]], "cudaq::qubitconnectivity (c++ type)": [[2, "_CPPv4N5cudaq17QubitConnectivityE"]], "cudaq::qubitedge (c++ type)": [[2, "_CPPv4N5cudaq9QubitEdgeE"]], "cudaq::remotecapabilities (c++ struct)": [[2, "_CPPv4N5cudaq18RemoteCapabilitiesE"]], "cudaq::remotecapabilities::remotecapabilities (c++ function)": [[2, "_CPPv4N5cudaq18RemoteCapabilities18RemoteCapabilitiesEb"]], "cudaq::remotecapabilities::serializedcodeexec (c++ member)": [[2, "_CPPv4N5cudaq18RemoteCapabilities18serializedCodeExecE"]], "cudaq::remotecapabilities::stateoverlap (c++ member)": [[2, "_CPPv4N5cudaq18RemoteCapabilities12stateOverlapE"]], "cudaq::remotecapabilities::vqe (c++ member)": [[2, "_CPPv4N5cudaq18RemoteCapabilities3vqeE"]], "cudaq::remotesimulationstate (c++ class)": [[2, "_CPPv4N5cudaq21RemoteSimulationStateE"]], "cudaq::resources (c++ class)": [[2, "_CPPv4N5cudaq9ResourcesE"]], "cudaq::serializedcodeexecutioncontext (c++ class)": [[2, "_CPPv4N5cudaq30SerializedCodeExecutionContextE"]], "cudaq::simulationstate (c++ class)": [[2, "_CPPv4N5cudaq15SimulationStateE"]], "cudaq::simulationstate::tensor (c++ struct)": [[2, "_CPPv4N5cudaq15SimulationState6TensorE"]], "cudaq::simulationstate::precision (c++ enum)": [[2, "_CPPv4N5cudaq15SimulationState9precisionE"]], "cudaq::simulationstate::precision::fp32 (c++ enumerator)": [[2, "_CPPv4N5cudaq15SimulationState9precision4fp32E"]], "cudaq::simulationstate::precision::fp64 (c++ enumerator)": [[2, "_CPPv4N5cudaq15SimulationState9precision4fp64E"]], "cudaq::tensorstatedata (c++ type)": [[2, "_CPPv4N5cudaq15TensorStateDataE"]], "cudaq::trace (c++ class)": [[2, "_CPPv4N5cudaq5TraceE"]], "cudaq::amplitude_damping_channel (c++ class)": [[2, "_CPPv4N5cudaq25amplitude_damping_channelE"]], "cudaq::async_result (c++ class)": [[2, "_CPPv4I0EN5cudaq12async_resultE"]], "cudaq::async_result::get (c++ function)": [[2, "_CPPv4N5cudaq12async_result3getEv"]], "cudaq::bit_flip_channel (c++ class)": [[2, "_CPPv4N5cudaq16bit_flip_channelE"]], "cudaq::complex (c++ type)": [[2, "_CPPv4N5cudaq7complexE"]], "cudaq::complex_matrix (c++ class)": [[2, "_CPPv4N5cudaq14complex_matrixE"]], "cudaq::complex_matrix::cols (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrix4colsEv"]], "cudaq::complex_matrix::complex_matrix (c++ function)": [[2, "_CPPv4N5cudaq14complex_matrix14complex_matrixEKNSt6size_tEKNSt6size_tE"], [2, "_CPPv4N5cudaq14complex_matrix14complex_matrixEP10value_typeKNSt6size_tEKNSt6size_tE"]], "cudaq::complex_matrix::data (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrix4dataEv"]], "cudaq::complex_matrix::dump (c++ function)": [[2, "_CPPv4N5cudaq14complex_matrix4dumpERNSt7ostreamE"], [2, "_CPPv4N5cudaq14complex_matrix4dumpEv"]], "cudaq::complex_matrix::eigenvalues (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrix11eigenvaluesEv"]], "cudaq::complex_matrix::eigenvectors (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrix12eigenvectorsEv"]], "cudaq::complex_matrix::minimal_eigenvalue (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrix18minimal_eigenvalueEv"]], "cudaq::complex_matrix::operator() (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrixclENSt6size_tENSt6size_tE"]], "cudaq::complex_matrix::operator* (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrixmlER14complex_matrix"], [2, "_CPPv4NK5cudaq14complex_matrixmlERNSt6vectorI10value_typeEE"]], "cudaq::complex_matrix::rows (c++ function)": [[2, "_CPPv4NK5cudaq14complex_matrix4rowsEv"]], "cudaq::complex_matrix::set_zero (c++ function)": [[2, "_CPPv4N5cudaq14complex_matrix8set_zeroEv"]], "cudaq::complex_matrix::value_type (c++ type)": [[2, "_CPPv4N5cudaq14complex_matrix10value_typeE"]], "cudaq::depolarization_channel (c++ class)": [[2, "_CPPv4N5cudaq22depolarization_channelE"]], "cudaq::details (c++ type)": [[2, "_CPPv4N5cudaq7detailsE"]], "cudaq::details::kernelbuildertype (c++ class)": [[2, "_CPPv4N5cudaq7details17KernelBuilderTypeE"]], "cudaq::details::kernelbuildertype::kernelbuildertype (c++ function)": [[2, "_CPPv4N5cudaq7details17KernelBuilderType17KernelBuilderTypeERRNSt8functionIFN4mlir4TypeEPN4mlir11MLIRContextEEEE"]], "cudaq::details::kernelbuildertype::create (c++ function)": [[2, "_CPPv4N5cudaq7details17KernelBuilderType6createEPN4mlir11MLIRContextE"]], "cudaq::details::future (c++ class)": [[2, "_CPPv4N5cudaq7details6futureE"]], "cudaq::details::future::future (c++ function)": [[2, "_CPPv4N5cudaq7details6future6futureERNSt6vectorI3JobEERNSt6stringERNSt3mapINSt6stringENSt6stringEEE"], [2, "_CPPv4N5cudaq7details6future6futureERR6future"], [2, "_CPPv4N5cudaq7details6future6futureEv"]], "cudaq::details::kernel_builder_base (c++ class)": [[2, "_CPPv4N5cudaq7details19kernel_builder_baseE"]], "cudaq::details::kernel_builder_base::operator<< (c++ function)": [[2, "_CPPv4N5cudaq7details19kernel_builder_baselsERNSt7ostreamERK19kernel_builder_base"]], "cudaq::draw (c++ function)": [[2, "_CPPv4I0Dp0EN5cudaq4drawENSt6stringERR13QuantumKernelDpRR4Args"]], "cudaq::dyn (c++ member)": [[2, "_CPPv4N5cudaq3dynE"]], "cudaq::gradient (c++ class)": [[2, "_CPPv4N5cudaq8gradientE"]], "cudaq::gradient::clone (c++ function)": [[2, "_CPPv4N5cudaq8gradient5cloneEv"]], "cudaq::gradient::compute (c++ function)": [[2, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd"], [2, "_CPPv4N5cudaq8gradient7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd"]], "cudaq::gradient::gradient (c++ function)": [[2, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelT"], [2, "_CPPv4I00EN5cudaq8gradient8gradientER7KernelTRR10ArgsMapper"], [2, "_CPPv4I00EN5cudaq8gradient8gradientERR13QuantumKernelRR10ArgsMapper"], [2, "_CPPv4N5cudaq8gradient8gradientERRNSt8functionIFvNSt6vectorIdEEEEE"], [2, "_CPPv4N5cudaq8gradient8gradientEv"]], "cudaq::gradient::setargs (c++ function)": [[2, "_CPPv4I0DpEN5cudaq8gradient7setArgsEvR13QuantumKernelDpRR4Args"]], "cudaq::gradient::setkernel (c++ function)": [[2, "_CPPv4I0EN5cudaq8gradient9setKernelEvR13QuantumKernel"]], "cudaq::gradients::central_difference (c++ class)": [[2, "_CPPv4N5cudaq9gradients18central_differenceE"]], "cudaq::gradients::central_difference::clone (c++ function)": [[2, "_CPPv4N5cudaq9gradients18central_difference5cloneEv"]], "cudaq::gradients::central_difference::compute (c++ function)": [[2, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd"], [2, "_CPPv4N5cudaq9gradients18central_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd"]], "cudaq::gradients::central_difference::gradient (c++ function)": [[2, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelT"], [2, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientER7KernelTRR10ArgsMapper"], [2, "_CPPv4I00EN5cudaq9gradients18central_difference8gradientERR13QuantumKernelRR10ArgsMapper"], [2, "_CPPv4N5cudaq9gradients18central_difference8gradientERRNSt8functionIFvNSt6vectorIdEEEEE"], [2, "_CPPv4N5cudaq9gradients18central_difference8gradientEv"]], "cudaq::gradients::forward_difference (c++ class)": [[2, "_CPPv4N5cudaq9gradients18forward_differenceE"]], "cudaq::gradients::forward_difference::clone (c++ function)": [[2, "_CPPv4N5cudaq9gradients18forward_difference5cloneEv"]], "cudaq::gradients::forward_difference::compute (c++ function)": [[2, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd"], [2, "_CPPv4N5cudaq9gradients18forward_difference7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd"]], "cudaq::gradients::forward_difference::gradient (c++ function)": [[2, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelT"], [2, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientER7KernelTRR10ArgsMapper"], [2, "_CPPv4I00EN5cudaq9gradients18forward_difference8gradientERR13QuantumKernelRR10ArgsMapper"], [2, "_CPPv4N5cudaq9gradients18forward_difference8gradientERRNSt8functionIFvNSt6vectorIdEEEEE"], [2, "_CPPv4N5cudaq9gradients18forward_difference8gradientEv"]], "cudaq::gradients::parameter_shift (c++ class)": [[2, "_CPPv4N5cudaq9gradients15parameter_shiftE"]], "cudaq::gradients::parameter_shift::clone (c++ function)": [[2, "_CPPv4N5cudaq9gradients15parameter_shift5cloneEv"]], "cudaq::gradients::parameter_shift::compute (c++ function)": [[2, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERKNSt8functionIFdNSt6vectorIdEEEEEd"], [2, "_CPPv4N5cudaq9gradients15parameter_shift7computeERKNSt6vectorIdEERNSt6vectorIdEERK7spin_opd"]], "cudaq::gradients::parameter_shift::gradient (c++ function)": [[2, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelT"], [2, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientER7KernelTRR10ArgsMapper"], [2, "_CPPv4I00EN5cudaq9gradients15parameter_shift8gradientERR13QuantumKernelRR10ArgsMapper"], [2, "_CPPv4N5cudaq9gradients15parameter_shift8gradientERRNSt8functionIFvNSt6vectorIdEEEEE"], [2, "_CPPv4N5cudaq9gradients15parameter_shift8gradientEv"]], "cudaq::kernel_builder (c++ class)": [[2, "_CPPv4IDpEN5cudaq14kernel_builderE"]], "cudaq::kernel_builder::constantval (c++ function)": [[2, "_CPPv4N5cudaq14kernel_builder11constantValEd"]], "cudaq::kernel_builder::getarguments (c++ function)": [[2, "_CPPv4N5cudaq14kernel_builder12getArgumentsEv"]], "cudaq::kernel_builder::getnumparams (c++ function)": [[2, "_CPPv4N5cudaq14kernel_builder12getNumParamsEv"]], "cudaq::kernel_builder::isargstdvec (c++ function)": [[2, "_CPPv4N5cudaq14kernel_builder11isArgStdVecENSt6size_tE"]], "cudaq::kernel_builder::kernel_builder (c++ function)": [[2, "_CPPv4N5cudaq14kernel_builder14kernel_builderERNSt6vectorIN7details17KernelBuilderTypeEEE"]], "cudaq::kernel_builder::name (c++ function)": [[2, "_CPPv4N5cudaq14kernel_builder4nameEv"]], "cudaq::kernel_builder::qalloc (c++ function)": [[2, "_CPPv4N5cudaq14kernel_builder6qallocE10QuakeValue"], [2, "_CPPv4N5cudaq14kernel_builder6qallocEKNSt6size_tE"], [2, "_CPPv4N5cudaq14kernel_builder6qallocERNSt6vectorINSt7complexIdEEEE"], [2, "_CPPv4N5cudaq14kernel_builder6qallocEv"]], "cudaq::kernel_builder::swap (c++ function)": [[2, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRK10QuakeValueRK10QuakeValueRK10QuakeValue"], [2, "_CPPv4I00EN5cudaq14kernel_builder4swapEvRKNSt6vectorI10QuakeValueEERK10QuakeValueRK10QuakeValue"], [2, "_CPPv4N5cudaq14kernel_builder4swapERK10QuakeValueRK10QuakeValue"]], "cudaq::kraus_channel (c++ class)": [[2, "_CPPv4N5cudaq13kraus_channelE"]], "cudaq::kraus_channel::empty (c++ function)": [[2, "_CPPv4NK5cudaq13kraus_channel5emptyEv"]], "cudaq::kraus_channel::get_ops (c++ function)": [[2, "_CPPv4N5cudaq13kraus_channel7get_opsEv"]], "cudaq::kraus_channel::kraus_channel (c++ function)": [[2, "_CPPv4IDpEN5cudaq13kraus_channel13kraus_channelEDpRRNSt16initializer_listI1TEE"], [2, "_CPPv4N5cudaq13kraus_channel13kraus_channelERK13kraus_channel"], [2, "_CPPv4N5cudaq13kraus_channel13kraus_channelERNSt6vectorI8kraus_opEE"], [2, "_CPPv4N5cudaq13kraus_channel13kraus_channelERRNSt6vectorI8kraus_opEE"], [2, "_CPPv4N5cudaq13kraus_channel13kraus_channelEv"]], "cudaq::kraus_channel::operator= (c++ function)": [[2, "_CPPv4N5cudaq13kraus_channelaSERK13kraus_channel"]], "cudaq::kraus_channel::operator[] (c++ function)": [[2, "_CPPv4N5cudaq13kraus_channelixEKNSt6size_tE"]], "cudaq::kraus_channel::push_back (c++ function)": [[2, "_CPPv4N5cudaq13kraus_channel9push_backE8kraus_op"]], "cudaq::kraus_channel::size (c++ function)": [[2, "_CPPv4NK5cudaq13kraus_channel4sizeEv"]], "cudaq::kraus_op (c++ struct)": [[2, "_CPPv4N5cudaq8kraus_opE"]], "cudaq::kraus_op::adjoint (c++ function)": [[2, "_CPPv4NK5cudaq8kraus_op7adjointEv"]], "cudaq::kraus_op::data (c++ member)": [[2, "_CPPv4N5cudaq8kraus_op4dataE"]], "cudaq::kraus_op::kraus_op (c++ function)": [[2, "_CPPv4I0EN5cudaq8kraus_op8kraus_opERRNSt16initializer_listI1TEE"], [2, "_CPPv4N5cudaq8kraus_op8kraus_opENSt6vectorIN5cudaq7complexEEE"], [2, "_CPPv4N5cudaq8kraus_op8kraus_opERK8kraus_op"]], "cudaq::kraus_op::ncols (c++ member)": [[2, "_CPPv4N5cudaq8kraus_op5nColsE"]], "cudaq::kraus_op::nrows (c++ member)": [[2, "_CPPv4N5cudaq8kraus_op5nRowsE"]], "cudaq::kraus_op::operator= (c++ function)": [[2, "_CPPv4N5cudaq8kraus_opaSERK8kraus_op"]], "cudaq::mpi (c++ type)": [[2, "_CPPv4N5cudaq3mpiE"]], "cudaq::mpi::all_gather (c++ function)": [[2, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIdEERKNSt6vectorIdEE"], [2, "_CPPv4N5cudaq3mpi10all_gatherERNSt6vectorIiEERKNSt6vectorIiEE"]], "cudaq::mpi::all_reduce (c++ function)": [[2, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK14BinaryFunction"], [2, "_CPPv4I00EN5cudaq3mpi10all_reduceE1TRK1TRK4Func"]], "cudaq::mpi::broadcast (c++ function)": [[2, "_CPPv4N5cudaq3mpi9broadcastERNSt6stringEi"], [2, "_CPPv4N5cudaq3mpi9broadcastERNSt6vectorIdEEi"]], "cudaq::mpi::finalize (c++ function)": [[2, "_CPPv4N5cudaq3mpi8finalizeEv"]], "cudaq::mpi::initialize (c++ function)": [[2, "_CPPv4N5cudaq3mpi10initializeEiPPc"], [2, "_CPPv4N5cudaq3mpi10initializeEv"]], "cudaq::mpi::is_initialized (c++ function)": [[2, "_CPPv4N5cudaq3mpi14is_initializedEv"]], "cudaq::mpi::num_ranks (c++ function)": [[2, "_CPPv4N5cudaq3mpi9num_ranksEv"]], "cudaq::mpi::rank (c++ function)": [[2, "_CPPv4N5cudaq3mpi4rankEv"]], "cudaq::noise_model (c++ class)": [[2, "_CPPv4N5cudaq11noise_modelE"]], "cudaq::noise_model::add_channel (c++ function)": [[2, "_CPPv4IDpEN5cudaq11noise_model11add_channelEvRKNSt6vectorINSt6size_tEEERK13kraus_channel"], [2, "_CPPv4N5cudaq11noise_model11add_channelERKNSt6stringERKNSt6vectorINSt6size_tEEERK13kraus_channel"]], "cudaq::noise_model::empty (c++ function)": [[2, "_CPPv4NK5cudaq11noise_model5emptyEv"]], "cudaq::noise_model::get_channels (c++ function)": [[2, "_CPPv4I0ENK5cudaq11noise_model12get_channelsENSt6vectorI13kraus_channelEERKNSt6vectorINSt6size_tEEE"], [2, "_CPPv4NK5cudaq11noise_model12get_channelsERKNSt6stringERKNSt6vectorINSt6size_tEEE"]], "cudaq::noise_model::noise_model (c++ function)": [[2, "_CPPv4N5cudaq11noise_model11noise_modelEv"]], "cudaq::num_available_gpus (c++ function)": [[2, "_CPPv4N5cudaq18num_available_gpusEv"]], "cudaq::observe_result (c++ class)": [[2, "_CPPv4N5cudaq14observe_resultE"]], "cudaq::observe_result::counts (c++ function)": [[2, "_CPPv4I0EN5cudaq14observe_result6countsE13sample_result10SpinOpType"]], "cudaq::observe_result::dump (c++ function)": [[2, "_CPPv4N5cudaq14observe_result4dumpEv"]], "cudaq::observe_result::expectation (c++ function)": [[2, "_CPPv4I0EN5cudaq14observe_result11expectationEd10SpinOpType"], [2, "_CPPv4N5cudaq14observe_result11expectationEv"]], "cudaq::observe_result::id_coefficient (c++ function)": [[2, "_CPPv4N5cudaq14observe_result14id_coefficientEv"]], "cudaq::observe_result::observe_result (c++ function)": [[2, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op"], [2, "_CPPv4N5cudaq14observe_result14observe_resultEdRK7spin_op13sample_result"]], "cudaq::observe_result::operator double (c++ function)": [[2, "_CPPv4N5cudaq14observe_resultcvdEv"]], "cudaq::observe_result::raw_data (c++ function)": [[2, "_CPPv4N5cudaq14observe_result8raw_dataEv"]], "cudaq::optimizable_function (c++ class)": [[2, "_CPPv4N5cudaq20optimizable_functionE"]], "cudaq::optimization_result (c++ type)": [[2, "_CPPv4N5cudaq19optimization_resultE"]], "cudaq::optimizer (c++ class)": [[2, "_CPPv4N5cudaq9optimizerE"]], "cudaq::optimizer::optimize (c++ function)": [[2, "_CPPv4N5cudaq9optimizer8optimizeEKiRR20optimizable_function"]], "cudaq::optimizer::requiresgradients (c++ function)": [[2, "_CPPv4N5cudaq9optimizer17requiresGradientsEv"]], "cudaq::phase_flip_channel (c++ class)": [[2, "_CPPv4N5cudaq18phase_flip_channelE"]], "cudaq::qreg (c++ class)": [[2, "_CPPv4I_NSt6size_tE_NSt6size_tE0EN5cudaq4qregE"]], "cudaq::qreg::back (c++ function)": [[2, "_CPPv4N5cudaq4qreg4backENSt6size_tE"], [2, "_CPPv4N5cudaq4qreg4backEv"]], "cudaq::qreg::begin (c++ function)": [[2, "_CPPv4N5cudaq4qreg5beginEv"]], "cudaq::qreg::clear (c++ function)": [[2, "_CPPv4N5cudaq4qreg5clearEv"]], "cudaq::qreg::front (c++ function)": [[2, "_CPPv4N5cudaq4qreg5frontENSt6size_tE"], [2, "_CPPv4N5cudaq4qreg5frontEv"]], "cudaq::qreg::operator[] (c++ function)": [[2, "_CPPv4N5cudaq4qregixEKNSt6size_tE"]], "cudaq::qreg::size (c++ function)": [[2, "_CPPv4NK5cudaq4qreg4sizeEv"]], "cudaq::qreg::slice (c++ function)": [[2, "_CPPv4N5cudaq4qreg5sliceENSt6size_tENSt6size_tE"]], "cudaq::qreg::value_type (c++ type)": [[2, "_CPPv4N5cudaq4qreg10value_typeE"]], "cudaq::qspan (c++ class)": [[2, "_CPPv4I_NSt6size_tE_NSt6size_tEEN5cudaq5qspanE"]], "cudaq::quantum_platform (c++ class)": [[2, "_CPPv4N5cudaq16quantum_platformE"]], "cudaq::quantum_platform::clear_shots (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform11clear_shotsEv"]], "cudaq::quantum_platform::connectivity (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform12connectivityEv"]], "cudaq::quantum_platform::enqueueasynctask (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tER19KernelExecutionTask"], [2, "_CPPv4N5cudaq16quantum_platform16enqueueAsyncTaskEKNSt6size_tERNSt8functionIFvvEEE"]], "cudaq::quantum_platform::getlogstream (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform12getLogStreamEv"]], "cudaq::quantum_platform::get_current_qpu (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform15get_current_qpuEv"]], "cudaq::quantum_platform::get_exec_ctx (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform12get_exec_ctxEv"]], "cudaq::quantum_platform::get_num_qubits (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform14get_num_qubitsENSt6size_tE"], [2, "_CPPv4N5cudaq16quantum_platform14get_num_qubitsEv"]], "cudaq::quantum_platform::get_remote_capabilities (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform23get_remote_capabilitiesEKNSt6size_tE"]], "cudaq::quantum_platform::get_shots (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform9get_shotsEv"]], "cudaq::quantum_platform::is_emulated (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform11is_emulatedEKNSt6size_tE"]], "cudaq::quantum_platform::is_remote (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform9is_remoteEKNSt6size_tE"]], "cudaq::quantum_platform::is_simulator (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform12is_simulatorEKNSt6size_tE"]], "cudaq::quantum_platform::launchvqe (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform9launchVQEEKNSt6stringEPKvPN5cudaq8gradientEN5cudaq7spin_opERN5cudaq9optimizerEKiKNSt6size_tE"]], "cudaq::quantum_platform::list_platforms (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform14list_platformsEv"]], "cudaq::quantum_platform::name (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform4nameEv"]], "cudaq::quantum_platform::num_qpus (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform8num_qpusEv"]], "cudaq::quantum_platform::onrandomseedset (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform15onRandomSeedSetENSt6size_tE"]], "cudaq::quantum_platform::resetlogstream (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform14resetLogStreamEv"]], "cudaq::quantum_platform::reset_exec_ctx (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform14reset_exec_ctxENSt6size_tE"]], "cudaq::quantum_platform::reset_noise (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform11reset_noiseEv"]], "cudaq::quantum_platform::setlogstream (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform12setLogStreamERNSt7ostreamE"]], "cudaq::quantum_platform::settargetbackend (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform16setTargetBackendERKNSt6stringE"]], "cudaq::quantum_platform::set_current_qpu (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform15set_current_qpuEKNSt6size_tE"]], "cudaq::quantum_platform::set_exec_ctx (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform12set_exec_ctxEPN5cudaq16ExecutionContextENSt6size_tE"]], "cudaq::quantum_platform::set_noise (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform9set_noiseEPK11noise_model"]], "cudaq::quantum_platform::set_shots (c++ function)": [[2, "_CPPv4N5cudaq16quantum_platform9set_shotsEi"]], "cudaq::quantum_platform::supports_conditional_feedback (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform29supports_conditional_feedbackEKNSt6size_tE"]], "cudaq::quantum_platform::supports_task_distribution (c++ function)": [[2, "_CPPv4NK5cudaq16quantum_platform26supports_task_distributionEv"]], "cudaq::qubit (c++ type)": [[2, "_CPPv4N5cudaq5qubitE"]], "cudaq::qudit (c++ class)": [[2, "_CPPv4I_NSt6size_tEEN5cudaq5quditE"]], "cudaq::qudit::qudit (c++ function)": [[2, "_CPPv4N5cudaq5qudit5quditEv"]], "cudaq::qvector (c++ class)": [[2, "_CPPv4I_NSt6size_tEEN5cudaq7qvectorE"]], "cudaq::qvector::back (c++ function)": [[2, "_CPPv4N5cudaq7qvector4backENSt6size_tE"], [2, "_CPPv4N5cudaq7qvector4backEv"]], "cudaq::qvector::begin (c++ function)": [[2, "_CPPv4N5cudaq7qvector5beginEv"]], "cudaq::qvector::clear (c++ function)": [[2, "_CPPv4N5cudaq7qvector5clearEv"]], "cudaq::qvector::end (c++ function)": [[2, "_CPPv4N5cudaq7qvector3endEv"]], "cudaq::qvector::front (c++ function)": [[2, "_CPPv4N5cudaq7qvector5frontENSt6size_tE"], [2, "_CPPv4N5cudaq7qvector5frontEv"]], "cudaq::qvector::operator= (c++ function)": [[2, "_CPPv4N5cudaq7qvectoraSERK7qvector"]], "cudaq::qvector::operator[] (c++ function)": [[2, "_CPPv4N5cudaq7qvectorixEKNSt6size_tE"]], "cudaq::qvector::qvector (c++ function)": [[2, "_CPPv4N5cudaq7qvector7qvectorENSt6size_tE"], [2, "_CPPv4N5cudaq7qvector7qvectorERK5state"], [2, "_CPPv4N5cudaq7qvector7qvectorERK7qvector"], [2, "_CPPv4N5cudaq7qvector7qvectorERKNSt6vectorI7complexEEb"], [2, "_CPPv4N5cudaq7qvector7qvectorERR7qvector"]], "cudaq::qvector::size (c++ function)": [[2, "_CPPv4NK5cudaq7qvector4sizeEv"]], "cudaq::qvector::slice (c++ function)": [[2, "_CPPv4N5cudaq7qvector5sliceENSt6size_tENSt6size_tE"]], "cudaq::qvector::value_type (c++ type)": [[2, "_CPPv4N5cudaq7qvector10value_typeE"]], "cudaq::qview (c++ class)": [[2, "_CPPv4I_NSt6size_tEEN5cudaq5qviewE"]], "cudaq::qview::value_type (c++ type)": [[2, "_CPPv4N5cudaq5qview10value_typeE"]], "cudaq::range (c++ function)": [[2, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType"], [2, "_CPPv4I00EN5cudaq5rangeENSt6vectorI11ElementTypeEE11ElementType11ElementType11ElementType"], [2, "_CPPv4N5cudaq5rangeENSt6size_tE"]], "cudaq::real (c++ type)": [[2, "_CPPv4N5cudaq4realE"]], "cudaq::registry (c++ type)": [[2, "_CPPv4N5cudaq8registryE"]], "cudaq::registry::registeredtype (c++ class)": [[2, "_CPPv4I0EN5cudaq8registry14RegisteredTypeE"]], "cudaq::sample_result (c++ class)": [[2, "_CPPv4N5cudaq13sample_resultE"]], "cudaq::sample_result::append (c++ function)": [[2, "_CPPv4N5cudaq13sample_result6appendER15ExecutionResult"]], "cudaq::sample_result::begin (c++ function)": [[2, "_CPPv4N5cudaq13sample_result5beginEv"], [2, "_CPPv4NK5cudaq13sample_result5beginEv"]], "cudaq::sample_result::cbegin (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result6cbeginEv"]], "cudaq::sample_result::cend (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result4cendEv"]], "cudaq::sample_result::clear (c++ function)": [[2, "_CPPv4N5cudaq13sample_result5clearEv"]], "cudaq::sample_result::count (c++ function)": [[2, "_CPPv4N5cudaq13sample_result5countENSt11string_viewEKNSt11string_viewE"]], "cudaq::sample_result::deserialize (c++ function)": [[2, "_CPPv4N5cudaq13sample_result11deserializeERNSt6vectorINSt6size_tEEE"]], "cudaq::sample_result::dump (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result4dumpERNSt7ostreamE"], [2, "_CPPv4NK5cudaq13sample_result4dumpEv"]], "cudaq::sample_result::end (c++ function)": [[2, "_CPPv4N5cudaq13sample_result3endEv"], [2, "_CPPv4NK5cudaq13sample_result3endEv"]], "cudaq::sample_result::exp_val_z (c++ function)": [[2, "_CPPv4N5cudaq13sample_result9exp_val_zEKNSt11string_viewE"]], "cudaq::sample_result::expectation (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result11expectationEKNSt11string_viewE"]], "cudaq::sample_result::get_marginal (c++ function)": [[2, "_CPPv4N5cudaq13sample_result12get_marginalERKNSt6vectorINSt6size_tEEEKNSt11string_viewE"], [2, "_CPPv4N5cudaq13sample_result12get_marginalERRKNSt6vectorINSt6size_tEEEKNSt11string_viewE"]], "cudaq::sample_result::has_even_parity (c++ function)": [[2, "_CPPv4N5cudaq13sample_result15has_even_parityENSt11string_viewE"]], "cudaq::sample_result::has_expectation (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result15has_expectationEKNSt11string_viewE"]], "cudaq::sample_result::most_probable (c++ function)": [[2, "_CPPv4N5cudaq13sample_result13most_probableEKNSt11string_viewE"]], "cudaq::sample_result::operator+= (c++ function)": [[2, "_CPPv4N5cudaq13sample_resultpLERK13sample_result"]], "cudaq::sample_result::operator= (c++ function)": [[2, "_CPPv4N5cudaq13sample_resultaSER13sample_result"]], "cudaq::sample_result::operator== (c++ function)": [[2, "_CPPv4NK5cudaq13sample_resulteqERK13sample_result"]], "cudaq::sample_result::probability (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result11probabilityENSt11string_viewEKNSt11string_viewE"]], "cudaq::sample_result::register_names (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result14register_namesEv"]], "cudaq::sample_result::reorder (c++ function)": [[2, "_CPPv4N5cudaq13sample_result7reorderERKNSt6vectorINSt6size_tEEEKNSt11string_viewE"]], "cudaq::sample_result::sample_result (c++ function)": [[2, "_CPPv4N5cudaq13sample_result13sample_resultER15ExecutionResult"], [2, "_CPPv4N5cudaq13sample_result13sample_resultERK13sample_result"], [2, "_CPPv4N5cudaq13sample_result13sample_resultERNSt6vectorI15ExecutionResultEE"], [2, "_CPPv4N5cudaq13sample_result13sample_resultERR15ExecutionResult"], [2, "_CPPv4N5cudaq13sample_result13sample_resultEdRNSt6vectorI15ExecutionResultEE"], [2, "_CPPv4N5cudaq13sample_result13sample_resultEv"]], "cudaq::sample_result::serialize (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result9serializeEv"]], "cudaq::sample_result::size (c++ function)": [[2, "_CPPv4N5cudaq13sample_result4sizeEKNSt11string_viewE"]], "cudaq::sample_result::to_map (c++ function)": [[2, "_CPPv4NK5cudaq13sample_result6to_mapEKNSt11string_viewE"]], "cudaq::sample_result::~sample_result (c++ function)": [[2, "_CPPv4N5cudaq13sample_resultD0Ev"]], "cudaq::set_noise (c++ function)": [[2, "_CPPv4N5cudaq9set_noiseERKN5cudaq11noise_modelE"]], "cudaq::set_random_seed (c++ function)": [[2, "_CPPv4N5cudaq15set_random_seedENSt6size_tE"]], "cudaq::simulation_precision (c++ enum)": [[2, "_CPPv4N5cudaq20simulation_precisionE"]], "cudaq::simulation_precision::fp32 (c++ enumerator)": [[2, "_CPPv4N5cudaq20simulation_precision4fp32E"]], "cudaq::simulation_precision::fp64 (c++ enumerator)": [[2, "_CPPv4N5cudaq20simulation_precision4fp64E"]], "cudaq::spin_op (c++ class)": [[2, "_CPPv4N5cudaq7spin_opE"]], "cudaq::spin_op::begin (c++ function)": [[2, "_CPPv4N5cudaq7spin_op5beginEv"], [2, "_CPPv4NK5cudaq7spin_op5beginEv"]], "cudaq::spin_op::csr_spmatrix (c++ type)": [[2, "_CPPv4N5cudaq7spin_op12csr_spmatrixE"]], "cudaq::spin_op::distribute_terms (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op16distribute_termsENSt6size_tE"]], "cudaq::spin_op::dump (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op4dumpEv"]], "cudaq::spin_op::end (c++ function)": [[2, "_CPPv4N5cudaq7spin_op3endEv"], [2, "_CPPv4NK5cudaq7spin_op3endEv"]], "cudaq::spin_op::for_each_pauli (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op14for_each_pauliERRNSt8functionIFv5pauliNSt6size_tEEEE"]], "cudaq::spin_op::for_each_term (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op13for_each_termERRNSt8functionIFvR7spin_opEEE"]], "cudaq::spin_op::from_word (c++ function)": [[2, "_CPPv4N5cudaq7spin_op9from_wordERKNSt6stringE"]], "cudaq::spin_op::getdatarepresentation (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op21getDataRepresentationEv"]], "cudaq::spin_op::getdatatuple (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op12getDataTupleEv"]], "cudaq::spin_op::get_coefficient (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op15get_coefficientEv"]], "cudaq::spin_op::get_raw_data (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op12get_raw_dataEv"]], "cudaq::spin_op::is_identity (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op11is_identityEv"]], "cudaq::spin_op::iterator (c++ struct)": [[2, "_CPPv4I0EN5cudaq7spin_op8iteratorE"]], "cudaq::spin_op::num_qubits (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op10num_qubitsEv"]], "cudaq::spin_op::num_terms (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op9num_termsEv"]], "cudaq::spin_op::operator*= (c++ function)": [[2, "_CPPv4N5cudaq7spin_opmLEKNSt7complexIdEE"], [2, "_CPPv4N5cudaq7spin_opmLEKd"], [2, "_CPPv4N5cudaq7spin_opmLERK7spin_op"]], "cudaq::spin_op::operator+= (c++ function)": [[2, "_CPPv4N5cudaq7spin_oppLERK7spin_op"]], "cudaq::spin_op::operator-= (c++ function)": [[2, "_CPPv4N5cudaq7spin_opmIERK7spin_op"]], "cudaq::spin_op::operator= (c++ function)": [[2, "_CPPv4N5cudaq7spin_opaSERK7spin_op"]], "cudaq::spin_op::operator== (c++ function)": [[2, "_CPPv4NK5cudaq7spin_opeqERK7spin_op"]], "cudaq::spin_op::random (c++ function)": [[2, "_CPPv4N5cudaq7spin_op6randomENSt6size_tENSt6size_tEj"]], "cudaq::spin_op::spin_op (c++ function)": [[2, "_CPPv4N5cudaq7spin_op7spin_opE5pauliKNSt6size_tENSt7complexIdEE"], [2, "_CPPv4N5cudaq7spin_op7spin_opENSt6size_tE"], [2, "_CPPv4N5cudaq7spin_op7spin_opERK12spin_op_termRKNSt7complexIdEE"], [2, "_CPPv4N5cudaq7spin_op7spin_opERK7spin_op"], [2, "_CPPv4N5cudaq7spin_op7spin_opERKNSt13unordered_mapI12spin_op_termNSt7complexIdEEEE"], [2, "_CPPv4N5cudaq7spin_op7spin_opERKNSt4pairIK12spin_op_termNSt7complexIdEEEE"], [2, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorI12spin_op_termEERKNSt6vectorINSt7complexIdEEEE"], [2, "_CPPv4N5cudaq7spin_op7spin_opERKNSt6vectorIdEENSt6size_tE"], [2, "_CPPv4N5cudaq7spin_op7spin_opERNSt4pairIK12spin_op_termNSt7complexIdEEEE"], [2, "_CPPv4N5cudaq7spin_op7spin_opEv"]], "cudaq::spin_op::spin_op_term (c++ type)": [[2, "_CPPv4N5cudaq7spin_op12spin_op_termE"]], "cudaq::spin_op::to_matrix (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op9to_matrixEv"]], "cudaq::spin_op::to_sparse_matrix (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op16to_sparse_matrixEv"]], "cudaq::spin_op::to_string (c++ function)": [[2, "_CPPv4NK5cudaq7spin_op9to_stringEb"]], "cudaq::spin_op::~spin_op (c++ function)": [[2, "_CPPv4N5cudaq7spin_opD0Ev"]], "cudaq::state (c++ class)": [[2, "_CPPv4N5cudaq5stateE"]], "cudaq::state::amplitude (c++ function)": [[2, "_CPPv4N5cudaq5state9amplitudeERKNSt6vectorIiEE"]], "cudaq::state::amplitudes (c++ function)": [[2, "_CPPv4N5cudaq5state10amplitudesERKNSt6vectorINSt6vectorIiEEEE"]], "cudaq::state::dump (c++ function)": [[2, "_CPPv4NK5cudaq5state4dumpERNSt7ostreamE"], [2, "_CPPv4NK5cudaq5state4dumpEv"]], "cudaq::state::from_data (c++ function)": [[2, "_CPPv4N5cudaq5state9from_dataERK10state_data"]], "cudaq::state::get_num_qubits (c++ function)": [[2, "_CPPv4NK5cudaq5state14get_num_qubitsEv"]], "cudaq::state::get_num_tensors (c++ function)": [[2, "_CPPv4NK5cudaq5state15get_num_tensorsEv"]], "cudaq::state::get_precision (c++ function)": [[2, "_CPPv4NK5cudaq5state13get_precisionEv"]], "cudaq::state::get_tensor (c++ function)": [[2, "_CPPv4NK5cudaq5state10get_tensorENSt6size_tE"]], "cudaq::state::get_tensors (c++ function)": [[2, "_CPPv4NK5cudaq5state11get_tensorsEv"]], "cudaq::state::is_on_gpu (c++ function)": [[2, "_CPPv4NK5cudaq5state9is_on_gpuEv"]], "cudaq::state::operator() (c++ function)": [[2, "_CPPv4N5cudaq5stateclENSt6size_tENSt6size_tE"], [2, "_CPPv4N5cudaq5stateclERKNSt16initializer_listINSt6size_tEEENSt6size_tE"]], "cudaq::state::operator= (c++ function)": [[2, "_CPPv4N5cudaq5stateaSERR5state"]], "cudaq::state::operator[] (c++ function)": [[2, "_CPPv4N5cudaq5stateixENSt6size_tE"]], "cudaq::state::overlap (c++ function)": [[2, "_CPPv4N5cudaq5state7overlapERK5state"]], "cudaq::state::state (c++ function)": [[2, "_CPPv4N5cudaq5state5stateEP15SimulationState"], [2, "_CPPv4N5cudaq5state5stateERK5state"]], "cudaq::state::to_host (c++ function)": [[2, "_CPPv4I0ENK5cudaq5state7to_hostEvPNSt7complexI10ScalarTypeEENSt6size_tE"]], "cudaq::state_data (c++ type)": [[2, "_CPPv4N5cudaq10state_dataE"]], "cudaq::tensor (c++ type)": [[2, "_CPPv4N5cudaq6tensorE"]], "cudaq::unset_noise (c++ function)": [[2, "_CPPv4N5cudaq11unset_noiseEv"]], "nvqir::mpssimulationstate (c++ class)": [[2, "_CPPv4N5nvqir18MPSSimulationStateE"]], "nvqir::tensornetsimulationstate (c++ class)": [[2, "_CPPv4N5nvqir24TensorNetSimulationStateE"]], "amplitudedampingchannel (class in cudaq)": [[3, "cudaq.AmplitudeDampingChannel"]], "asyncobserveresult (class in cudaq)": [[3, "cudaq.AsyncObserveResult"]], "asyncsampleresult (class in cudaq)": [[3, "cudaq.AsyncSampleResult"]], "asyncstateresult (class in cudaq)": [[3, "cudaq.AsyncStateResult"]], "bitflipchannel (class in cudaq)": [[3, "cudaq.BitFlipChannel"]], "cobyla (class in cudaq.optimizers)": [[3, "cudaq.optimizers.COBYLA"]], "centraldifference (class in cudaq.gradients)": [[3, "cudaq.gradients.CentralDifference"]], "complexmatrix (class in cudaq)": [[3, "cudaq.ComplexMatrix"]], "depolarizationchannel (class in cudaq)": [[3, "cudaq.DepolarizationChannel"]], "forwarddifference (class in cudaq.gradients)": [[3, "cudaq.gradients.ForwardDifference"]], "gradientdescent (class in cudaq.optimizers)": [[3, "cudaq.optimizers.GradientDescent"]], "kernel (in module cudaq)": [[3, "cudaq.Kernel"]], "krauschannel (class in cudaq)": [[3, "cudaq.KrausChannel"]], "krausoperator (class in cudaq)": [[3, "cudaq.KrausOperator"]], "lbfgs (class in cudaq.optimizers)": [[3, "cudaq.optimizers.LBFGS"]], "neldermead (class in cudaq.optimizers)": [[3, "cudaq.optimizers.NelderMead"]], "noisemodel (class in cudaq)": [[3, "cudaq.NoiseModel"]], "observeresult (class in cudaq)": [[3, "cudaq.ObserveResult"]], "optimizationresult (class in cudaq)": [[3, "cudaq.OptimizationResult"]], "parametershift (class in cudaq.gradients)": [[3, "cudaq.gradients.ParameterShift"]], "phaseflipchannel (class in cudaq)": [[3, "cudaq.PhaseFlipChannel"]], "pykernel (class in cudaq)": [[3, "cudaq.PyKernel"]], "pykerneldecorator (class in cudaq)": [[3, "cudaq.PyKernelDecorator"]], "quakevalue (class in cudaq)": [[3, "cudaq.QuakeValue"]], "sampleresult (class in cudaq)": [[3, "cudaq.SampleResult"]], "simulationprecision (class in cudaq)": [[3, "cudaq.SimulationPrecision"]], "spinoperator (class in cudaq)": [[3, "cudaq.SpinOperator"]], "state (class in cudaq)": [[3, "cudaq.State"]], "target (class in cudaq)": [[3, "cudaq.Target"]], "tensor (class in cudaq)": [[3, "cudaq.Tensor"]], "__add__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__add__"]], "__add__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__add__"]], "__call__() (cudaq.pykerneldecorator method)": [[3, "cudaq.PyKernelDecorator.__call__"]], "__eq__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__eq__"]], "__getitem__() (cudaq.complexmatrix method)": [[3, "cudaq.ComplexMatrix.__getitem__"]], "__getitem__() (cudaq.krauschannel method)": [[3, "cudaq.KrausChannel.__getitem__"]], "__getitem__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__getitem__"]], "__getitem__() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.__getitem__"]], "__init__() (cudaq.amplitudedampingchannel method)": [[3, "cudaq.AmplitudeDampingChannel.__init__"]], "__init__() (cudaq.bitflipchannel method)": [[3, "cudaq.BitFlipChannel.__init__"]], "__init__() (cudaq.depolarizationchannel method)": [[3, "cudaq.DepolarizationChannel.__init__"]], "__init__() (cudaq.noisemodel method)": [[3, "cudaq.NoiseModel.__init__"]], "__init__() (cudaq.phaseflipchannel method)": [[3, "cudaq.PhaseFlipChannel.__init__"]], "__iter__() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.__iter__"]], "__iter__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__iter__"]], "__len__() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.__len__"]], "__mul__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__mul__"]], "__mul__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__mul__"]], "__neg__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__neg__"]], "__radd__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__radd__"]], "__radd__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__radd__"]], "__rmul__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__rmul__"]], "__rmul__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__rmul__"]], "__rsub__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__rsub__"]], "__rsub__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__rsub__"]], "__str__() (cudaq.complexmatrix method)": [[3, "cudaq.ComplexMatrix.__str__"]], "__str__() (cudaq.pykerneldecorator method)": [[3, "cudaq.PyKernelDecorator.__str__"]], "__sub__() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.__sub__"]], "__sub__() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.__sub__"]], "add_channel() (cudaq.noisemodel method)": [[3, "cudaq.NoiseModel.add_channel"]], "all_gather() (in module cudaq.mpi)": [[3, "cudaq.mpi.all_gather"]], "amplitude() (cudaq.state method)": [[3, "cudaq.State.amplitude"]], "amplitudes() (cudaq.state method)": [[3, "cudaq.State.amplitudes"]], "append() (cudaq.krauschannel method)": [[3, "cudaq.KrausChannel.append"]], "argument_count (cudaq.pykernel attribute)": [[3, "cudaq.PyKernel.argument_count"]], "arguments (cudaq.pykernel attribute)": [[3, "cudaq.PyKernel.arguments"]], "broadcast() (in module cudaq.mpi)": [[3, "cudaq.mpi.broadcast"]], "clear() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.clear"]], "col_count (cudaq.krausoperator property)": [[3, "cudaq.KrausOperator.col_count"]], "compile() (cudaq.pykerneldecorator method)": [[3, "cudaq.PyKernelDecorator.compile"]], "compute() (cudaq.gradients.centraldifference method)": [[3, "cudaq.gradients.CentralDifference.compute"]], "compute() (cudaq.gradients.forwarddifference method)": [[3, "cudaq.gradients.ForwardDifference.compute"]], "compute() (cudaq.gradients.parametershift method)": [[3, "cudaq.gradients.ParameterShift.compute"]], "count() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.count"]], "counts() (cudaq.observeresult method)": [[3, "cudaq.ObserveResult.counts"]], "cudaq": [[3, "module-cudaq"]], "description (cudaq.target property)": [[3, "cudaq.Target.description"]], "distribute_terms() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.distribute_terms"]], "draw() (in module cudaq)": [[3, "cudaq.draw"]], "dump() (cudaq.observeresult method)": [[3, "cudaq.ObserveResult.dump"]], "dump() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.dump"]], "dump() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.dump"]], "dump() (cudaq.state method)": [[3, "cudaq.State.dump"]], "expectation() (cudaq.observeresult method)": [[3, "cudaq.ObserveResult.expectation"]], "expectation() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.expectation"]], "expectation_z() (cudaq.observeresult method)": [[3, "cudaq.ObserveResult.expectation_z"]], "expectation_z() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.expectation_z"]], "finalize() (in module cudaq.mpi)": [[3, "cudaq.mpi.finalize"]], "for_each_pauli() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.for_each_pauli"]], "for_each_term() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.for_each_term"]], "from_data() (cudaq.state static method)": [[3, "cudaq.State.from_data"]], "from_json() (cudaq.pykerneldecorator static method)": [[3, "cudaq.PyKernelDecorator.from_json"]], "from_json() (cudaq.spinoperator static method)": [[3, "cudaq.SpinOperator.from_json"]], "from_json() (cudaq.gradients.centraldifference static method)": [[3, "cudaq.gradients.CentralDifference.from_json"]], "from_json() (cudaq.gradients.forwarddifference static method)": [[3, "cudaq.gradients.ForwardDifference.from_json"]], "from_json() (cudaq.gradients.parametershift static method)": [[3, "cudaq.gradients.ParameterShift.from_json"]], "from_json() (cudaq.optimizers.cobyla static method)": [[3, "cudaq.optimizers.COBYLA.from_json"]], "from_json() (cudaq.optimizers.gradientdescent static method)": [[3, "cudaq.optimizers.GradientDescent.from_json"]], "from_json() (cudaq.optimizers.lbfgs static method)": [[3, "cudaq.optimizers.LBFGS.from_json"]], "from_json() (cudaq.optimizers.neldermead static method)": [[3, "cudaq.optimizers.NelderMead.from_json"]], "from_word() (cudaq.spinoperator static method)": [[3, "cudaq.SpinOperator.from_word"]], "get() (cudaq.asyncobserveresult method)": [[3, "cudaq.AsyncObserveResult.get"]], "get() (cudaq.asyncsampleresult method)": [[3, "cudaq.AsyncSampleResult.get"]], "get() (cudaq.asyncstateresult method)": [[3, "cudaq.AsyncStateResult.get"]], "gettensor() (cudaq.state method)": [[3, "cudaq.State.getTensor"]], "gettensors() (cudaq.state method)": [[3, "cudaq.State.getTensors"]], "get_channels() (cudaq.noisemodel method)": [[3, "cudaq.NoiseModel.get_channels"]], "get_coefficient() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.get_coefficient"]], "get_marginal_counts() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.get_marginal_counts"]], "get_precision() (cudaq.target method)": [[3, "cudaq.Target.get_precision"]], "get_qubit_count() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.get_qubit_count"]], "get_raw_data() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.get_raw_data"]], "get_register_counts() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.get_register_counts"]], "get_sequential_data() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.get_sequential_data"]], "get_spin() (cudaq.observeresult method)": [[3, "cudaq.ObserveResult.get_spin"]], "get_state() (in module cudaq)": [[3, "cudaq.get_state"]], "get_state_async() (in module cudaq)": [[3, "cudaq.get_state_async"]], "get_target() (in module cudaq)": [[3, "cudaq.get_target"]], "get_targets() (in module cudaq)": [[3, "cudaq.get_targets"]], "get_term_count() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.get_term_count"]], "gradient (class in cudaq.gradients)": [[3, "cudaq.gradients.gradient"]], "has_target() (in module cudaq)": [[3, "cudaq.has_target"]], "initial_parameters (cudaq.optimizers.cobyla property)": [[3, "cudaq.optimizers.COBYLA.initial_parameters"]], "initial_parameters (cudaq.optimizers.gradientdescent property)": [[3, "cudaq.optimizers.GradientDescent.initial_parameters"]], "initial_parameters (cudaq.optimizers.lbfgs property)": [[3, "cudaq.optimizers.LBFGS.initial_parameters"]], "initial_parameters (cudaq.optimizers.neldermead property)": [[3, "cudaq.optimizers.NelderMead.initial_parameters"]], "initialize() (in module cudaq.mpi)": [[3, "cudaq.mpi.initialize"]], "initialize_cudaq() (in module cudaq)": [[3, "cudaq.initialize_cudaq"]], "is_emulated() (cudaq.target method)": [[3, "cudaq.Target.is_emulated"]], "is_identity() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.is_identity"]], "is_initialized() (in module cudaq.mpi)": [[3, "cudaq.mpi.is_initialized"]], "is_on_gpu() (cudaq.state method)": [[3, "cudaq.State.is_on_gpu"]], "is_remote() (cudaq.target method)": [[3, "cudaq.Target.is_remote"]], "items() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.items"]], "kernel() (in module cudaq)": [[3, "cudaq.kernel"]], "lower_bounds (cudaq.optimizers.cobyla property)": [[3, "cudaq.optimizers.COBYLA.lower_bounds"]], "lower_bounds (cudaq.optimizers.gradientdescent property)": [[3, "cudaq.optimizers.GradientDescent.lower_bounds"]], "lower_bounds (cudaq.optimizers.lbfgs property)": [[3, "cudaq.optimizers.LBFGS.lower_bounds"]], "lower_bounds (cudaq.optimizers.neldermead property)": [[3, "cudaq.optimizers.NelderMead.lower_bounds"]], "make_kernel() (in module cudaq)": [[3, "cudaq.make_kernel"]], "max_iterations (cudaq.optimizers.cobyla property)": [[3, "cudaq.optimizers.COBYLA.max_iterations"]], "max_iterations (cudaq.optimizers.gradientdescent property)": [[3, "cudaq.optimizers.GradientDescent.max_iterations"]], "max_iterations (cudaq.optimizers.lbfgs property)": [[3, "cudaq.optimizers.LBFGS.max_iterations"]], "max_iterations (cudaq.optimizers.neldermead property)": [[3, "cudaq.optimizers.NelderMead.max_iterations"]], "minimal_eigenvalue() (cudaq.complexmatrix method)": [[3, "cudaq.ComplexMatrix.minimal_eigenvalue"]], "module": [[3, "module-cudaq"]], "most_probable() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.most_probable"]], "name (cudaq.pykernel attribute)": [[3, "cudaq.PyKernel.name"]], "name (cudaq.simulationprecision property)": [[3, "cudaq.SimulationPrecision.name"]], "name (cudaq.target property)": [[3, "cudaq.Target.name"]], "num_available_gpus() (in module cudaq)": [[3, "cudaq.num_available_gpus"]], "num_qpus() (cudaq.target method)": [[3, "cudaq.Target.num_qpus"]], "num_qubits() (cudaq.state method)": [[3, "cudaq.State.num_qubits"]], "num_ranks() (in module cudaq.mpi)": [[3, "cudaq.mpi.num_ranks"]], "observe() (in module cudaq)": [[3, "cudaq.observe"]], "observe_async() (in module cudaq)": [[3, "cudaq.observe_async"]], "optimize() (cudaq.optimizers.cobyla method)": [[3, "cudaq.optimizers.COBYLA.optimize"]], "optimize() (cudaq.optimizers.gradientdescent method)": [[3, "cudaq.optimizers.GradientDescent.optimize"]], "optimize() (cudaq.optimizers.lbfgs method)": [[3, "cudaq.optimizers.LBFGS.optimize"]], "optimize() (cudaq.optimizers.neldermead method)": [[3, "cudaq.optimizers.NelderMead.optimize"]], "optimizer (class in cudaq.optimizers)": [[3, "cudaq.optimizers.optimizer"]], "overlap() (cudaq.state method)": [[3, "cudaq.State.overlap"]], "platform (cudaq.target property)": [[3, "cudaq.Target.platform"]], "probability() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.probability"]], "qreg (in module cudaq)": [[3, "cudaq.qreg"]], "qubit (class in cudaq)": [[3, "cudaq.qubit"]], "qvector (class in cudaq)": [[3, "cudaq.qvector"]], "random() (cudaq.spinoperator static method)": [[3, "cudaq.SpinOperator.random"]], "rank() (in module cudaq.mpi)": [[3, "cudaq.mpi.rank"]], "register_names (cudaq.sampleresult attribute)": [[3, "cudaq.SampleResult.register_names"]], "requires_gradients() (cudaq.optimizers.cobyla method)": [[3, "cudaq.optimizers.COBYLA.requires_gradients"]], "requires_gradients() (cudaq.optimizers.gradientdescent method)": [[3, "cudaq.optimizers.GradientDescent.requires_gradients"]], "requires_gradients() (cudaq.optimizers.lbfgs method)": [[3, "cudaq.optimizers.LBFGS.requires_gradients"]], "requires_gradients() (cudaq.optimizers.neldermead method)": [[3, "cudaq.optimizers.NelderMead.requires_gradients"]], "reset_target() (in module cudaq)": [[3, "cudaq.reset_target"]], "row_count (cudaq.krausoperator property)": [[3, "cudaq.KrausOperator.row_count"]], "sample() (in module cudaq)": [[3, "cudaq.sample"]], "sample_async() (in module cudaq)": [[3, "cudaq.sample_async"]], "serialize() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.serialize"]], "set_noise() (in module cudaq)": [[3, "cudaq.set_noise"]], "set_random_seed() (in module cudaq)": [[3, "cudaq.set_random_seed"]], "set_target() (in module cudaq)": [[3, "cudaq.set_target"]], "simulator (cudaq.target property)": [[3, "cudaq.Target.simulator"]], "slice() (cudaq.quakevalue method)": [[3, "cudaq.QuakeValue.slice"]], "spin.i() (in module cudaq)": [[3, "cudaq.spin.i"]], "spin.x() (in module cudaq)": [[3, "cudaq.spin.x"]], "spin.y() (in module cudaq)": [[3, "cudaq.spin.y"]], "spin.z() (in module cudaq)": [[3, "cudaq.spin.z"]], "to_json() (cudaq.pykerneldecorator method)": [[3, "cudaq.PyKernelDecorator.to_json"]], "to_json() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.to_json"]], "to_json() (cudaq.gradients.centraldifference method)": [[3, "cudaq.gradients.CentralDifference.to_json"]], "to_json() (cudaq.gradients.forwarddifference method)": [[3, "cudaq.gradients.ForwardDifference.to_json"]], "to_json() (cudaq.gradients.parametershift method)": [[3, "cudaq.gradients.ParameterShift.to_json"]], "to_json() (cudaq.optimizers.cobyla method)": [[3, "cudaq.optimizers.COBYLA.to_json"]], "to_json() (cudaq.optimizers.gradientdescent method)": [[3, "cudaq.optimizers.GradientDescent.to_json"]], "to_json() (cudaq.optimizers.lbfgs method)": [[3, "cudaq.optimizers.LBFGS.to_json"]], "to_json() (cudaq.optimizers.neldermead method)": [[3, "cudaq.optimizers.NelderMead.to_json"]], "to_matrix() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.to_matrix"]], "to_sparse_matrix() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.to_sparse_matrix"]], "to_string() (cudaq.spinoperator method)": [[3, "cudaq.SpinOperator.to_string"]], "translate() (in module cudaq)": [[3, "cudaq.translate"]], "type_to_str() (cudaq.pykerneldecorator static method)": [[3, "cudaq.PyKernelDecorator.type_to_str"]], "unset_noise() (in module cudaq)": [[3, "cudaq.unset_noise"]], "upper_bounds (cudaq.optimizers.cobyla property)": [[3, "cudaq.optimizers.COBYLA.upper_bounds"]], "upper_bounds (cudaq.optimizers.gradientdescent property)": [[3, "cudaq.optimizers.GradientDescent.upper_bounds"]], "upper_bounds (cudaq.optimizers.lbfgs property)": [[3, "cudaq.optimizers.LBFGS.upper_bounds"]], "upper_bounds (cudaq.optimizers.neldermead property)": [[3, "cudaq.optimizers.NelderMead.upper_bounds"]], "values() (cudaq.sampleresult method)": [[3, "cudaq.SampleResult.values"]], "vqe() (in module cudaq)": [[3, "cudaq.vqe"]]}}) \ No newline at end of file diff --git a/pr-2023/specification/cudaq.html b/pr-2023/specification/cudaq.html index b5aad24862..2c24fd6102 100644 --- a/pr-2023/specification/cudaq.html +++ b/pr-2023/specification/cudaq.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/specification/cudaq/algorithmic_primitives.html b/pr-2023/specification/cudaq/algorithmic_primitives.html index 9b8bb8effe..3442b61b61 100644 --- a/pr-2023/specification/cudaq/algorithmic_primitives.html +++ b/pr-2023/specification/cudaq/algorithmic_primitives.html @@ -126,7 +126,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -319,8 +332,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -505,6 +524,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/specification/cudaq/control_flow.html b/pr-2023/specification/cudaq/control_flow.html index bfc8e4f490..8896a9ffeb 100644 --- a/pr-2023/specification/cudaq/control_flow.html +++ b/pr-2023/specification/cudaq/control_flow.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/specification/cudaq/dynamic_kernels.html b/pr-2023/specification/cudaq/dynamic_kernels.html index 3686d9a86d..0ad20f3d6c 100644 --- a/pr-2023/specification/cudaq/dynamic_kernels.html +++ b/pr-2023/specification/cudaq/dynamic_kernels.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/specification/cudaq/examples.html b/pr-2023/specification/cudaq/examples.html index af41d6d213..5b781697ca 100644 --- a/pr-2023/specification/cudaq/examples.html +++ b/pr-2023/specification/cudaq/examples.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/specification/cudaq/kernels.html b/pr-2023/specification/cudaq/kernels.html index e3b12bb1eb..6af68b43e7 100644 --- a/pr-2023/specification/cudaq/kernels.html +++ b/pr-2023/specification/cudaq/kernels.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/specification/cudaq/machine_model.html b/pr-2023/specification/cudaq/machine_model.html index 2c85c28758..fd7a3601d6 100644 --- a/pr-2023/specification/cudaq/machine_model.html +++ b/pr-2023/specification/cudaq/machine_model.html @@ -126,7 +126,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -319,8 +332,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -505,6 +524,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/specification/cudaq/namespace.html b/pr-2023/specification/cudaq/namespace.html index 33eed3d32f..77c0775404 100644 --- a/pr-2023/specification/cudaq/namespace.html +++ b/pr-2023/specification/cudaq/namespace.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/specification/cudaq/operations.html b/pr-2023/specification/cudaq/operations.html index a9b8e959d7..2551be9110 100644 --- a/pr-2023/specification/cudaq/operations.html +++ b/pr-2023/specification/cudaq/operations.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/specification/cudaq/operators.html b/pr-2023/specification/cudaq/operators.html index 4a51bda362..4eccf76320 100644 --- a/pr-2023/specification/cudaq/operators.html +++ b/pr-2023/specification/cudaq/operators.html @@ -126,7 +126,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -319,8 +332,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -505,6 +524,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/specification/cudaq/patterns.html b/pr-2023/specification/cudaq/patterns.html index af5a12453c..b0e025e422 100644 --- a/pr-2023/specification/cudaq/patterns.html +++ b/pr-2023/specification/cudaq/patterns.html @@ -126,7 +126,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -319,8 +332,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -505,6 +524,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/specification/cudaq/platform.html b/pr-2023/specification/cudaq/platform.html index 80b2453311..100ba209ad 100644 --- a/pr-2023/specification/cudaq/platform.html +++ b/pr-2023/specification/cudaq/platform.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/specification/cudaq/synthesis.html b/pr-2023/specification/cudaq/synthesis.html index 6b97be7c8b..384c871898 100644 --- a/pr-2023/specification/cudaq/synthesis.html +++ b/pr-2023/specification/cudaq/synthesis.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/specification/cudaq/types.html b/pr-2023/specification/cudaq/types.html index 1636bc7291..1522d7323f 100644 --- a/pr-2023/specification/cudaq/types.html +++ b/pr-2023/specification/cudaq/types.html @@ -126,7 +126,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -319,8 +332,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -505,6 +524,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/specification/index.html b/pr-2023/specification/index.html index 5472ea238b..5890e42085 100644 --- a/pr-2023/specification/index.html +++ b/pr-2023/specification/index.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/specification/quake-dialect.html b/pr-2023/specification/quake-dialect.html index f433ebaedc..3cd22e7ae5 100644 --- a/pr-2023/specification/quake-dialect.html +++ b/pr-2023/specification/quake-dialect.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/sphinx/api/default_ops.rst b/pr-2023/sphinx/api/default_ops.rst index 6b1a33ebc9..c82271e826 100644 --- a/pr-2023/sphinx/api/default_ops.rst +++ b/pr-2023/sphinx/api/default_ops.rst @@ -541,4 +541,95 @@ This is a non-linear transformation, and no template overloads are available. .. code-block:: cpp cudaq::qubit qubit; - my(qubit); \ No newline at end of file + my(qubit); + + +User-Defined Custom Operations +============================== + +Users can define a custom quantum operation by its unitary matrix. First use +the API to register a custom operation, outside of a CUDA-Q kernel. Then the +operation can be used within a CUDA-Q kernel like any of the built-in operations +defined above. +Custom operations are supported on qubits only (`qudit` with `level = 2`). + +.. tab:: Python + + The :code:`cudaq.register_operation` API accepts an identifier string for + the custom operation and its unitary matrix. The matrix can be a `list` or + `numpy` array of complex numbers. A 1D matrix is interpreted as row-major. + + + .. code-block:: python + + import cudaq + import numpy as np + + cudaq.register_operation("custom_h", 1. / np.sqrt(2.) * np.array([1, 1, 1, -1])) + + cudaq.register_operation("custom_x", np.array([0, 1, 1, 0])) + + @cudaq.kernel + def bell(): + qubits = cudaq.qvector(2) + custom_h(qubits[0]) + custom_x.ctrl(qubits[0], qubits[1]) + + cudaq.sample(bell).dump() + + +.. tab:: C++ + + The macro :code:`CUDAQ_REGISTER_OPERATION` accepts a unique name for the + operation, the number of target qubits, the number of rotation parameters + (can be 0), and the unitary matrix as a 1D row-major `std::vector` + representation. + + .. code-block:: cpp + + #include + + CUDAQ_REGISTER_OPERATION(custom_h, 1, 0, + {M_SQRT1_2, M_SQRT1_2, M_SQRT1_2, -M_SQRT1_2}) + + CUDAQ_REGISTER_OPERATION(custom_x, 1, 0, {0, 1, 1, 0}) + + __qpu__ void bell_pair() { + cudaq::qubit q, r; + custom_h(q); + custom_x(q, r); + } + + int main() { + auto counts = cudaq::sample(bell_pair); + for (auto &[bits, count] : counts) { + printf("%s\n", bits.data()); + } + } + + +For multi-qubit operations, the matrix is interpreted with MSB qubit ordering, +i.e. big-endian convention. The following example shows two different custom +operations, each operating on 2 qubits. + + +.. tab:: Python + + .. literalinclude:: ../snippets/python/using/examples/two_qubit_custom_op.py + :language: python + :start-after: [Begin Docs] + :end-before: [End Docs] + + +.. tab:: C++ + + .. literalinclude:: ../snippets/cpp/using/two_qubit_custom_op.cpp + :language: cpp + :start-after: [Begin Docs] + :end-before: [End Docs] + + +.. note:: + + Custom operations are currently supported only on :doc:`../using/backends/simulators`. + Attempt to use with a hardware backend will result in runtime error. diff --git a/pr-2023/sphinx/examples/python/providers/oqc.py b/pr-2023/sphinx/examples/python/providers/oqc.py index 7cb00f538e..d333746b05 100644 --- a/pr-2023/sphinx/examples/python/providers/oqc.py +++ b/pr-2023/sphinx/examples/python/providers/oqc.py @@ -1,5 +1,4 @@ import cudaq -import os # You only have to set the target once! No need to redefine it # for every execution call on your kernel. diff --git a/pr-2023/sphinx/examples/python/tutorials/Divisive_clustering.ipynb b/pr-2023/sphinx/examples/python/tutorials/Divisive_clustering.ipynb new file mode 100644 index 0000000000..b3730dcb43 --- /dev/null +++ b/pr-2023/sphinx/examples/python/tutorials/Divisive_clustering.ipynb @@ -0,0 +1,1088 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Divisive Clustering With Coresets Using CUDA-Q" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This tutorial will explore a CUDA-Q implementation of recent research (ArXiv Paper: https://arxiv.org/pdf/2402.01529.pdf) performed by a team from the University of Edinburgh. This tutorial was jointly developed by NVIDIA and the authors so users can better understand their method and explore how CUDA-Q removed barriers to scaling. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The code for this tutorial is based off the MIT licensed code found here: https://github.com/Boniface316/bigdata_vqa" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Clustering is a common unsupervised learning technique aimed at grouping data with similar characteristics. The unique properties of quantum computers could allow for enhanced pattern finding in clustering applications and enable more reliable data analysis. However, quantum computers today are severely limited by qubit count and noise. Performing practical clustering applications would require far too many qubits. The Edinburgh team developed a new method (extending the work of Harrow) to leverage coresets for clustering applications on quantum computers and use far fewer qubits. This tutorial will walk through an example using this approach for divisive clustering and emphasize the utility of CUDA-Q for scaling quantum simulations.\n", + "\n", + "The goal of divisive clustering is to begin with all data points as one set, and iteratively bipartition the data until each point is its own cluster. The branching behavior of this process can be used to understand similarities in the data points.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# If you are running outside of a CUDA-Q container or CUDA-Q directory tree, you may need to uncomment these lines to fetch the files.\n", + "# If you are running inside a CUDA-Q tree, then this step can be skipped.\n", + "# !mkdir divisive_clustering_src\n", + "# !wget -P divisive_clustering_src https://raw.githubusercontent.com/NVIDIA/cuda-quantum/main/docs/sphinx/examples/python/tutorials/divisive_clustering_src/divisive_clustering.py\n", + "# !wget -P divisive_clustering_src https://raw.githubusercontent.com/NVIDIA/cuda-quantum/main/docs/sphinx/examples/python/tutorials/divisive_clustering_src/main_divisive_clustering.py" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Install the relevant packages.\n", + "!pip install mpi4py==3.1.6\n", + "!pip install networkx==2.8.8\n", + "!pip install pandas==2.2.2\n", + "!pip install scikit-learn==1.4.2\n", + "!pip install tqdm==4.66.2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import cudaq\n", + "from cudaq import spin\n", + "\n", + "\n", + "# Auxillary Imports\n", + "import os\n", + "import numpy as np\n", + "import networkx as nx\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import warnings\n", + "from typing import Tuple\n", + "from divisive_clustering_src.divisive_clustering import Coreset, DivisiveClustering, Dendrogram, Voironi_Tessalation\n", + "\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The settings below are global parameters for the quantum simulation and can be toggled by the user. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "circuit_depth = 1\n", + "max_iterations = 75\n", + "max_shots = 1000" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "Given a data set $X = (x_1, x_2, \\cdots, x_N)$, a coreset is weighted data set of much smaller size ($X', w$) that represents $X$ enough such that analysis of ($X', w$) can allow us to draw reasonable approximate conclusions about $X$. There are various approaches to build coresets. They can be found in Practical Coreset Construction for Machine Learning (https://arxiv.org/pdf/1703.06476.pdf) and New Streaming Algorithms for Coresets in Machine Learning (https://arxiv.org/pdf/1703.06476.pdf).\n", + "\n", + "\n", + "Essentially, coreset construction boils down to finding the optimal coreset size and weights given some error tolerance. Given the constraints of a quantum computer, in this work, a coreset size is selected $a$ $priori$, and the error is determined for each model.\n", + "\n", + "\n", + "The following is an example $M=10$ coreset constructed from a 1000-point data set and loaded into a pandas data frame. See the image below where the coreset is represented by the black stars, the size of which corresponds to the weights.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using BFL2 method to generate coresets\n", + " X Y weights Name\n", + "0 7.028364 1.669787 234.230716 A\n", + "1 7.167441 0.354792 101.319288 B\n", + "2 1.022889 -0.921443 125.158339 C\n", + "3 2.706134 -2.636852 13.650774 D\n", + "4 6.998497 0.455847 116.758239 E\n", + "5 7.507918 0.630311 120.727176 F\n", + "6 -2.102508 2.297727 53.294127 G\n", + "7 5.722463 1.400433 77.415840 H\n", + "8 -1.425868 2.341136 42.847985 I\n", + "9 7.985373 -0.063209 240.116237 J\n" + ] + } + ], + "source": [ + "raw_data = Coreset.create_dataset(1000)\n", + "coreset = Coreset(\n", + " raw_data=raw_data,\n", + " number_of_sampling_for_centroids=10,\n", + " coreset_size=10,\n", + " number_of_coresets_to_evaluate=4,\n", + " coreset_method=\"BFL2\",\n", + ")\n", + "\n", + "\n", + "coreset_vectors, coreset_weights = coreset.get_best_coresets()\n", + "\n", + "coreset_df = pd.DataFrame(\n", + " {\"X\": coreset_vectors[:, 0], \"Y\": coreset_vectors[:, 1], \"weights\": coreset_weights}\n", + ")\n", + "coreset_df[\"Name\"] = [chr(i + 65) for i in coreset_df.index]\n", + "print(coreset_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(raw_data[:, 0], raw_data[:, 1], label=\"Raw Data\", c=\"#7eba00\")\n", + "plt.scatter(\n", + " coreset_df[\"X\"],\n", + " coreset_df[\"Y\"],\n", + " s=coreset_df[\"weights\"],\n", + " label=\"Coreset\",\n", + " color=\"black\",\n", + " marker=\"*\",\n", + ")\n", + "plt.xlabel(\"X\")\n", + "plt.ylabel(\"Y\")\n", + "plt.title(\"Raw data and its best 10 coreset using BFL2\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data preprocessing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to cluster data on a quantum computer, the task needs to be cast into the form of a binary optimization problem. Each qubit represents a coreset point, and the quantum algorithm determines how to bipartition the coreset points at each iteration of the divisive clustering routine. \n", + "\n", + "The first step is to convert coreset points into a fully connected graph. The edge weight is calculated by:\n", + "\n", + "$e_{ij} = w_iw_jd_{ij}$ where $d_{ij}$ is the Euclidean distance between points $i$ and $j$. \n", + "\n", + "This process is handled by `Coreset.coreset_to_graph()`. The function returns a fully connected graph $G$ with edge weights." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quantum functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The divisive clustering problem will be implemented on a quantum computer using a variational quantum algorithm (VQA) approach. A VQA takes a Hamiltonian (encoded with the optimization problem) and a parameterized ansatz and evaluates expectation values (quantum computer) that inform updates to the ansatz parameters (classical computer). The graph $G$ (Code in the \"src\" file) is used to construct the Hamiltonian, derived specifically for the divisive clustering problem, and motivated by a max-cut Hamiltonian. The `spin.z(i)` method in CUDA-Q adds a Pauli Z operation that acts on qubit $i$ to the Hamiltonian." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def get_K2_Hamiltonian(G: nx.Graph) -> cudaq.SpinOperator:\n", + " \"\"\"Returns the K2 Hamiltonian for the given graph G\n", + "\n", + " Args:\n", + " G (nx.Graph): Weighted graph\n", + " \"\"\"\n", + " H = 0\n", + "\n", + " for i, j in G.edges():\n", + " weight = G[i][j][\"weight\"]\n", + " H += weight * (spin.z(i) * spin.z(j))\n", + "\n", + " return H" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The code below constructs a quantum kernel, defining the circuit which will serve as an ansatz. The structure of the circuit is a hardware efficient ansatz consisting of layers of parameterized $R_Z$ and $R_Y$ gate acting on each qubit, followed by a linear cascade of CNOT gates, and two more rotation gates.\n", + "\n", + "The `@cudaq.kernel` decorator allows us to define a quantum circuit in the new kernel mode syntax which provides performance benefits to JIT compilation." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def get_VQE_circuit(number_of_qubits: int, circuit_depth: int) -> cudaq.Kernel:\n", + " \"\"\"Returns the VQE circuit for the given number of qubits and circuit depth\n", + "\n", + " Args:\n", + " number_of_qubits (int): Number of qubits\n", + " circuit_depth (int): Circuit depth\n", + "\n", + " Returns:\n", + " cudaq.Kernel: VQE Circuit\n", + " \"\"\"\n", + "\n", + " @cudaq.kernel\n", + " def kernel(thetas: list[float], number_of_qubits: int, circuit_depth: int):\n", + " \"\"\"VQE Circuit\n", + "\n", + " Args:\n", + " thetas (list[float]): List of parameters\n", + " number_of_qubits (int): Number of qubits\n", + " circuit_depth (int): Circuit depth\n", + " \"\"\"\n", + " qubits = cudaq.qvector(number_of_qubits)\n", + "\n", + " theta_position = 0\n", + "\n", + " for i in range(circuit_depth):\n", + " for j in range(number_of_qubits):\n", + " ry(thetas[theta_position], qubits[j])\n", + " rz(thetas[theta_position + 1], qubits[j])\n", + "\n", + " theta_position += 2\n", + "\n", + " for j in range(number_of_qubits - 1):\n", + " cx(qubits[j], qubits[j + 1])\n", + "\n", + " for j in range(number_of_qubits):\n", + " ry(thetas[theta_position], qubits[j])\n", + " rz(thetas[theta_position + 1], qubits[j])\n", + "\n", + " theta_position += 2\n", + "\n", + " return kernel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can visualize the circuit using the `cudaq.draw()` method. Below, we are drawing the circuit for 5 qubits." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ╭────────────╮ ╭────────────╮ ╭────────────╮╭────────────╮»\n", + "q0 : ┤ ry(0.8904) ├─┤ rz(0.7335) ├───●──┤ ry(0.4343) ├┤ rz(0.2236) ├»\n", + " ├────────────┤ ├────────────┤ ╭─┴─╮╰────────────╯├────────────┤»\n", + "q1 : ┤ ry(0.7937) ├─┤ rz(0.9981) ├─┤ x ├──────●───────┤ ry(0.3945) ├»\n", + " ├───────────┬╯ ├────────────┤ ╰───╯ ╭─┴─╮ ╰────────────╯»\n", + "q2 : ┤ ry(0.696) ├──┤ rz(0.3352) ├──────────┤ x ├───────────●───────»\n", + " ├───────────┴╮╭┴────────────┤ ╰───╯ ╭─┴─╮ »\n", + "q3 : ┤ ry(0.6658) ├┤ rz(0.05277) ├────────────────────────┤ x ├─────»\n", + " ├───────────┬╯├─────────────┴╮ ╰───╯ »\n", + "q4 : ┤ ry(0.791) ├─┤ rz(0.003569) ├─────────────────────────────────»\n", + " ╰───────────╯ ╰──────────────╯ »\n", + "\n", + "################################################################################\n", + "\n", + " \n", + "─────────────────────────────────────────────\n", + "╭────────────╮ \n", + "┤ rz(0.4119) ├───────────────────────────────\n", + "├────────────┤╭────────────╮ \n", + "┤ ry(0.3205) ├┤ rz(0.3504) ├─────────────────\n", + "╰────────────╯├────────────┤ ╭────────────╮ \n", + "──────●───────┤ ry(0.3913) ├─┤ rz(0.7392) ├──\n", + " ╭─┴─╮ ├────────────┤╭┴────────────┴─╮\n", + "────┤ x ├─────┤ ry(0.3171) ├┤ rz(0.0008056) ├\n", + " ╰───╯ ╰────────────╯╰───────────────╯\n", + "\n" + ] + } + ], + "source": [ + "parameter_count = 4 * circuit_depth * 5\n", + "parameters = np.random.rand(parameter_count)\n", + "\n", + "circuit = get_VQE_circuit(5, circuit_depth)\n", + "print(cudaq.draw(circuit, parameters, 5, circuit_depth))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next step is to select a classical optimizer. There are multiple [optimizers](https://nvidia.github.io/cuda-quantum/latest/api/languages/python_api.html#optimizers) built-in to CUDA-Q that can be selected. The code below returns the optimizer with the proper number of initial parameters. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def get_optimizer(\n", + " optimizer: cudaq.optimizers.optimizer, max_iterations, **kwargs\n", + ") -> Tuple[cudaq.optimizers.optimizer, int]:\n", + " \"\"\"Returns the optimizer with the given parameters\n", + "\n", + " Args:\n", + " optimizer (cudaq.optimizers.optimizer): Optimizer\n", + " max_iterations (int): Maximum number of iterations\n", + " **kwargs: Additional arguments\n", + "\n", + " Returns:\n", + " tuple(cudaq.optimizers.optimizer, int): Optimizer and parameter count\n", + " \"\"\"\n", + " parameter_count = 4 * kwargs[\"circuit_depth\"] * kwargs[\"qubits\"]\n", + " initial_params = np.random.uniform(-np.pi / 8.0, np.pi / 8.0, parameter_count)\n", + " optimizer.initial_parameters = initial_params\n", + "\n", + " optimizer.max_iterations = max_iterations\n", + " return optimizer, parameter_count" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Divisive Clustering Function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `DivisiveClusteringVQA` class enables the procedure to iteratively bipartition the coreset points until each is its own cluster. If you wish to develop on top of this or see how the underlying code works, please see the `divisive_clustering.py` file in the src directory. \n", + "\n", + "`run_divisive_clustering`, takes the current iteration's coreset points that will be bipartitioned as inputs, extracts the appropriate weights, and builds a graph $G$. The graph is then an input into the `get_counts_from_simulation` function. \n", + "\n", + "\n", + "`get_counts_from_simulation` handles preparation and execution of the quantum simulation. First, it takes $G$ and from it builds a spin Hamiltonian. Second, it defines a cost function, which in this case is a lambda function that returns the expectation value of our parameterized quantum circuit and the Hamiltonian. This value is obtained using the CUDA-Q `observe` command, accelerated by GPUs. After the expectation value is minimized, the quantum circuit corresponding to the optimal parameters is sampled using the CUDA-Q `sample` function. The bitstrings and their associated counts are returned by `get_counts_from_simulation`.\n", + "\n", + "A subset of these counts is evaluated to compute their exact cost. The best bitstring is returned and later used to assign the coreset points to one of two clusters.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "class DivisiveClusteringVQA(DivisiveClustering):\n", + " def __init__(\n", + " self,\n", + " **kwargs,\n", + " ):\n", + " super().__init__(**kwargs)\n", + "\n", + " def run_divisive_clustering(\n", + " self,\n", + " coreset_vectors_df_for_iteration: pd.DataFrame,\n", + " ):\n", + " \"\"\"Runs the Divisive Clustering algorithm\n", + "\n", + " Args:\n", + " coreset_vectors_df_for_iteration (pd.DataFrame): Coreset vectors for the iteration\n", + "\n", + " Returns:\n", + " str: Best bitstring\n", + "\n", + " \"\"\"\n", + " coreset_vectors_for_iteration_np, coreset_weights_for_iteration_np = (\n", + " self._get_iteration_coreset_vectors_and_weights(coreset_vectors_df_for_iteration)\n", + " )\n", + "\n", + " G = Coreset.coreset_to_graph(\n", + " coreset_vectors_for_iteration_np,\n", + " coreset_weights_for_iteration_np,\n", + " metric=self.coreset_to_graph_metric,\n", + " )\n", + "\n", + " counts = self.get_counts_from_simulation(\n", + " G,\n", + " self.circuit_depth,\n", + " self.max_iterations,\n", + " self.max_shots,\n", + " )\n", + "\n", + " return self._get_best_bitstring(counts, G)\n", + "\n", + " def get_counts_from_simulation(\n", + " self, G: nx.graph, circuit_depth: int, max_iterations: int, max_shots: int\n", + " ) -> cudaq.SampleResult:\n", + " \"\"\"\n", + " Runs the VQA simulation\n", + "\n", + " Args:\n", + " G (nx.graph): Graph\n", + " circuit_depth (int): Circuit depth\n", + " max_iterations (int): Maximum number of iterations\n", + " max_shots (int): Maximum number of shots\n", + "\n", + " Returns:\n", + " cudaq.SampleResult: Measurement from the experiment\n", + " \"\"\"\n", + "\n", + " qubits = len(G.nodes)\n", + " Hamiltonian = self.create_Hamiltonian(G)\n", + " optimizer, parameter_count = self.optimizer_function(\n", + " self.optimizer, max_iterations, qubits=qubits, circuit_depth=circuit_depth\n", + " )\n", + "\n", + " kernel = self.create_circuit(qubits, circuit_depth)\n", + "\n", + " def objective_function(\n", + " parameter_vector: list[float],\n", + " hamiltonian: cudaq.SpinOperator = Hamiltonian,\n", + " kernel: cudaq.Kernel = kernel,\n", + " ) -> float:\n", + " \"\"\"\n", + "\n", + " Objective function that returns the cost of the simulation\n", + "\n", + " Args:\n", + " parameter_vector (List[float]):\n", + " hamiltonian (cudaq.SpinOperator): Circuit parameter values as a vector\n", + " kernel (cudaq.Kernel) : Circuit configuration\n", + "\n", + " Returns:\n", + " float: Expectation value of the circuit\n", + "\n", + " \"\"\"\n", + "\n", + " get_result = lambda parameter_vector: cudaq.observe(\n", + " kernel, hamiltonian, parameter_vector, qubits, circuit_depth\n", + " ).expectation()\n", + "\n", + " cost = get_result(parameter_vector)\n", + "\n", + " return cost\n", + "\n", + " energy, optimal_parameters = optimizer.optimize(\n", + " dimensions=parameter_count, function=objective_function\n", + " )\n", + "\n", + " counts = cudaq.sample(\n", + " kernel, optimal_parameters, qubits, circuit_depth, shots_count=max_shots\n", + " )\n", + "\n", + " return counts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An instance of the `DivisiveClusteringVQA` class is mostly constructed from variables previously discussed like the functions for building the Hamiltonians and quantum circuits. Parameters related to the quantum simulation can also be specified here such as `circuit_depth` and `max_shots`. The ` threshold_for_max_cut` parameter specifies what percent of the sample results from the quantum computer are checked for the best bitstring value.\n", + "\n", + "The other options specify advanced features like if the data is normalized and how the graph weights are computed.\n", + "\n", + "\n", + "Finally, the `get_divisive_sequence` method performs the iterations and produces the clustering data which we will analyze below. Note that this postprocessing code is not exposed in this tutorial but can be found in the source code. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 129/129 [00:00<00:00, 12075.19it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 35025.50it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 18/18 [00:00<00:00, 44254.09it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 15827.56it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 13617.87it/s]\n" + ] + } + ], + "source": [ + "optimizer = cudaq.optimizers.COBYLA()\n", + "\n", + "divisive_clustering = DivisiveClusteringVQA(\n", + " circuit_depth=circuit_depth,\n", + " max_iterations=max_iterations,\n", + " max_shots=max_shots,\n", + " threshold_for_max_cut=0.75,\n", + " create_Hamiltonian=get_K2_Hamiltonian,\n", + " optimizer=optimizer,\n", + " optimizer_function=get_optimizer,\n", + " create_circuit=get_VQE_circuit,\n", + " normalize_vectors=True,\n", + " sort_by_descending=True,\n", + " coreset_to_graph_metric=\"dist\",\n", + ")\n", + "\n", + "hierarchial_clustering_sequence = divisive_clustering.get_divisive_sequence(coreset_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The data can be nicely visualized with a Dendrogram which maps where the bipartitionings occurred. Early splits generally mark divisions between the least similar data." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dendo = Dendrogram(coreset_df, hierarchial_clustering_sequence)\n", + "dendo.plot_dendrogram(plot_title=\"Dendrogram of Coreset using VQE\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each branch point in the dendrogram aboves corresponds to one of the plots below. Notice the first iterations are the most complicated, and the final iterations become trivial bipartitioning of two points. Occasionally, especially in the first iteration, the partitioning might be puzzling at first glance. The data might seem to naturally cluster into two groups. However, there are cases where a stray point seems to belong in the wrong cluster. There are two explanations for this. 1) The quantum sampling is approximate and stochastic. It is possible that too few shots were taken to sample the ground state of the problem. 2) It is important to remember that we are clustering coresets and not data points. There can be cases where it is optimal to pay a penalty by excluding a point based on proximity if the weights are small enough that the penalty has less impact. Usually, if a point looks unusually clustered and you go look at the original coresets plotted above, that point will have a small weight." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Dendrogram.plot_hierarchial_split(hierarchial_clustering_sequence, coreset_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The hierarchical clustering can be converted to flat clustering by drawing a line perpendicular to the branches. Any data point that intersects the line is considered to be in the same cluster. The function below performs this task at threshold height of 1.5. If you want to use the number of clusters instead of height, you can use `dendo.get_clusters_using_k()` method. You pass the number of desired clusters as an argument. The figure below shows the clusters that are formed at threshold height of 1.5." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "threshold_height = 1\n", + "clusters = dendo.get_clusters_using_height(threshold_height)\n", + "colors = [\"red\", \"blue\", \"green\", \"black\", \"purple\", \"orange\", \"yellow\"]\n", + "dendo.plot_dendrogram(\n", + " plot_title=\"Dendrogram of Coreset using VQE\",\n", + " colors=colors,\n", + " clusters=clusters,\n", + " color_threshold=threshold_height,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can visualize the flat clusters using `dendo.plot_clusters()` method. The function takes the clusters and colors as arguments. The clusters are represented by different colors." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dendo.plot_clusters(\n", + " clusters, colors, plot_title=\"Clusters of Coreset using VQE\", show_annotation=True\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The function below uses the `dendo.get_voronoi_tessalation()` method to convert the clusters into regions. `coreset_df`, `clusters` and `colors` need to be passed as the arguments to create the regions. This function creates a region for each coreset point separately and then colors them according to the clusters with colors passed as arguments. Another option is to create regions using the centroids of the clusters. You need to pass `tesslation_by_cluster=True` to the function to perform this task.\n", + "\n", + "Once the region creation is complete, you can use `plot_voironi()` method to plot the regions. The function takes the clusters and colors as arguments. \n", + "\n", + "Remembering that these regions were based on coresets, they can overlay the original data set and be used to cluster the data based on the coreset analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "vt = Voironi_Tessalation(coreset_df, clusters, colors, tesslation_by_cluster=False)\n", + "vt.plot_voironi(plot_title=\"Voironi Tessalation of Coreset using VQE\", show_annotation=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## QAOA Implementation\n", + "\n", + "CUDA-Q is designed to be a flexible tool for developers so they can test different implementations of the same code. For example, one can perform the same analysis, instead using a QAOA approach. Only the kernel needs to be changed as is done below." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " »\n", + "q0 : ──●──────────────────●──────────────────────────────────────────────────»\n", + " ╭─┴─╮╭────────────╮╭─┴─╮ »\n", + "q1 : ┤ x ├┤ rz(0.3527) ├┤ x ├──●──────────────────●──────────────────────────»\n", + " ╰───╯╰────────────╯╰───╯╭─┴─╮╭────────────╮╭─┴─╮ »\n", + "q2 : ────────────────────────┤ x ├┤ rz(0.3527) ├┤ x ├──●──────────────────●──»\n", + " ╰───╯╰────────────╯╰───╯╭─┴─╮╭────────────╮╭─┴─╮»\n", + "q3 : ────────────────────────────────────────────────┤ x ├┤ rz(0.3527) ├┤ x ├»\n", + " ╰───╯╰────────────╯╰───╯»\n", + "q4 : ────────────────────────────────────────────────────────────────────────»\n", + " »\n", + "\n", + "################################################################################\n", + "\n", + " ╭───╮╭────────────╮╭───╮╭───────────╮\n", + "────────────────────────┤ x ├┤ rz(0.3527) ├┤ x ├┤ rx(1.111) ├\n", + " ╰─┬─╯╰────────────╯╰─┬─╯├───────────┤\n", + "──────────────────────────┼──────────────────┼──┤ rx(1.111) ├\n", + " │ │ ├───────────┤\n", + "──────────────────────────┼──────────────────┼──┤ rx(1.111) ├\n", + " │ │ ├───────────┤\n", + "──●──────────────────●────┼──────────────────┼──┤ rx(1.111) ├\n", + "╭─┴─╮╭────────────╮╭─┴─╮ │ │ ├───────────┤\n", + "┤ x ├┤ rz(0.3527) ├┤ x ├──●──────────────────●──┤ rx(1.111) ├\n", + "╰───╯╰────────────╯╰───╯ ╰───────────╯\n", + "\n" + ] + } + ], + "source": [ + "def get_QAOA_circuit(number_of_qubits, circuit_depth) -> cudaq.Kernel:\n", + " \"\"\"Returns the QAOA circuit for the given number of qubits and circuit depth\n", + "\n", + "\n", + " Args:\n", + " number_of_qubits (int): Number of qubits\n", + " circuit_depth (int): Circuit depth\n", + "\n", + " Returns:\n", + " cudaq.Kernel: QAOA Circuit\n", + " \"\"\"\n", + "\n", + " @cudaq.kernel\n", + " def kernel(thetas: list[float], number_of_qubits: int, circuit_depth: int):\n", + " qubits = cudaq.qvector(number_of_qubits)\n", + "\n", + " layers = circuit_depth\n", + "\n", + " for layer in range(layers):\n", + " for qubit in range(number_of_qubits):\n", + " cx(qubits[qubit], qubits[(qubit + 1) % number_of_qubits])\n", + " rz(2.0 * thetas[layer], qubits[(qubit + 1) % number_of_qubits])\n", + " cx(qubits[qubit], qubits[(qubit + 1) % number_of_qubits])\n", + "\n", + " rx(2.0 * thetas[layer + layers], qubits)\n", + "\n", + " return kernel\n", + "\n", + "\n", + "circuit = get_QAOA_circuit(5, circuit_depth)\n", + "\n", + "print(cudaq.draw(circuit, np.random.rand(2 * circuit_depth), 5, circuit_depth))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def get_optimizer(\n", + " optimizer: cudaq.optimizers.optimizer, max_iterations, **kwargs\n", + ") -> Tuple[cudaq.optimizers.optimizer, int]:\n", + " \"\"\"\n", + " Returns the optimizer with the given parameters\n", + "\n", + " Args:\n", + " optimizer (cudaq.optimizers.optimizer): Optimizer\n", + " max_iterations (int): Maximum number of iterations\n", + " **kwargs: Additional arguments\n", + "\n", + " Returns:\n", + " tuple(cudaq.optimizers.optimizer, int): Optimizer and parameter count\n", + " \"\"\"\n", + "\n", + " parameter_count = 2 * kwargs[\"circuit_depth\"]\n", + " optimizer.initial_parameters = np.random.uniform(-np.pi / 8.0, np.pi / 8.0, parameter_count)\n", + " optimizer.max_iterations = max_iterations\n", + " return optimizer, parameter_count" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 484/484 [00:00<00:00, 12163.89it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:00<00:00, 52703.30it/s]\n", + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 48/48 [00:00<00:00, 31987.07it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 36393.09it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 37957.50it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:00<00:00, 42473.96it/s]\n" + ] + } + ], + "source": [ + "optimizer = cudaq.optimizers.COBYLA()\n", + "\n", + "divisive_clustering = DivisiveClusteringVQA(\n", + " circuit_depth=circuit_depth,\n", + " max_iterations=max_iterations,\n", + " max_shots=max_shots,\n", + " threshold_for_max_cut=0.75,\n", + " create_Hamiltonian=get_K2_Hamiltonian,\n", + " optimizer=optimizer,\n", + " optimizer_function=get_optimizer,\n", + " create_circuit=get_QAOA_circuit,\n", + " normalize_vectors=True,\n", + " sort_by_descending=True,\n", + " coreset_to_graph_metric=\"dist\",\n", + ")\n", + "\n", + "hierarchial_clustering_sequence = divisive_clustering.get_divisive_sequence(coreset_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scaling simulations with CUDA-Q\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The University of Edinburgh team quickly encountered scaling challenges when they were developing this method. By developing with CUDA-Q they were able to port their code to an HPC environment once GPUs became available. GPUs massively accelerated their development and testing and allowed them to produce the 25 qubit experiments presented in their publication. If you have a GPU available, run the following code examples and see how the times compare on your device. Each call executes the divisive clustering procedure using the QAOA method, 100000 simulated shots for each VQE loop, and maximum 75 VQE iterations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, try a slightly larger N=18 problem using the CPU (`qpp-cpu`) backend." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Uncomment the following line if you want to explicitly execute this step on your system.\n", + "# !python3 divisive_clustering_src/main_divisive_clustering.py --target qpp-cpu --M 18" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now try the N=18 example on the GPU backend (`nvidia`)." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using BFL2 method to generate coresets\n", + "100%|███████████████████████████████████████| 751/751 [00:00<00:00, 3460.26it/s]\n", + "100%|████████████████████████████████████████| 16/16 [00:00<00:00, 42771.74it/s]\n", + "100%|█████████████████████████████████████| 4064/4064 [00:00<00:00, 6862.37it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 56871.92it/s]\n", + "100%|████████████████████████████████████████| 16/16 [00:00<00:00, 44979.13it/s]\n", + "100%|██████████████████████████████████████| 128/128 [00:00<00:00, 19366.94it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 53773.13it/s]\n", + "100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 54648.91it/s]\n", + "100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 51941.85it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 56111.09it/s]\n", + "Total time for the execution: 461.866833317\n", + "Total time spent on CUDA-Q: 10.452308367999706\n" + ] + } + ], + "source": [ + "!python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia --M 18" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Scaling up to N=25, the task becomes even more onerous on a CPU. Depending on your device, the simulation may not even run. Try it and feel free to interrupt after your patience has worn out." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# target = 'qpp-cpu'\n", + "# Uncomment the following line if you want to explicitly execute this step on your system.\n", + "# !python3 divisive_clustering_src/main_divisive_clustering.py --target qpp-cpu --M 25" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "N=25 can still easily be completed by a single GPU." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using BFL2 method to generate coresets\n", + "100%|█████████████████████████████████████| 7352/7352 [00:03<00:00, 2063.82it/s]\n", + "100%|███████████████████████████████████| 16492/16492 [00:03<00:00, 4739.44it/s]\n", + "100%|██████████████████████████████████████| 256/256 [00:00<00:00, 15185.58it/s]\n", + "100%|████████████████████████████████████████| 64/64 [00:00<00:00, 23728.05it/s]\n", + "100%|██████████████████████████████████████| 256/256 [00:00<00:00, 15437.97it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 50840.05it/s]\n", + "100%|████████████████████████████████████████| 32/32 [00:00<00:00, 33562.82it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 54120.05it/s]\n", + "100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 54560.05it/s]\n", + "100%|██████████████████████████████████████████| 8/8 [00:00<00:00, 55924.05it/s]\n", + "100%|████████████████████████████████████████| 16/16 [00:00<00:00, 42717.29it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 55007.27it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 53601.33it/s]\n", + "100%|██████████████████████████████████████████| 4/4 [00:00<00:00, 47127.01it/s]\n", + "Total time for the execution: 67.61674502899999\n", + "Total time spent on CUDA-Q: 21.439895901\n" + ] + } + ], + "source": [ + "# target = 'nvidia'\n", + "!python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia --M 25" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we want to push the simulation to an $N=34$ coreset, a single GPU (assuming A100) will run out of memory. Run the code below to see for yourself. " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using BFL2 method to generate coresets\n", + "RuntimeError: NLOpt runtime error: nlopt failure\n" + ] + } + ], + "source": [ + "# target = 'nvidia'\n", + "!python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia --M 34" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To compute a problem with 34 qubits, we need to pool the memory of multiple GPUs. If you have multiple GPUs available, try the code below to run the same computation on 4 GPUs. You do not need to wait for the code to finish, just note how it does not fail immediately due to memory issues." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using BFL2 method to generate coresets\n", + "Using BFL2 method to generate coresets\n", + "Using BFL2 method to generate coresets\n", + "Using BFL2 method to generate coresets\n", + "^C\n" + ] + } + ], + "source": [ + "# target = 'nvidia-mgpu'\n", + "gpu_count = !nvidia-smi -L | wc -l\n", + "try:\n", + " gpu_count = int(gpu_count[0])\n", + "except:\n", + " gpu_count = 0 \n", + "if gpu_count >= 4:\n", + " !mpirun -np 4 python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia-mgpu --M 34\n", + "else:\n", + " print(f'Not enough GPUs found on this system ({gpu_count}) to run this step')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/pr-2023/sphinx/examples/python/tutorials/divisive_clustering_src/divisive_clustering.py b/pr-2023/sphinx/examples/python/tutorials/divisive_clustering_src/divisive_clustering.py new file mode 100644 index 0000000000..e9e8763838 --- /dev/null +++ b/pr-2023/sphinx/examples/python/tutorials/divisive_clustering_src/divisive_clustering.py @@ -0,0 +1,1270 @@ +from abc import ABC, abstractmethod +from typing import Callable, Dict, List, Optional, Tuple, Union + +import cudaq +import networkx as nx +import numpy as np +import pandas as pd +from matplotlib import pyplot as plt +from scipy.cluster.hierarchy import dendrogram, fcluster +from scipy.spatial import Voronoi +from scipy.stats import multivariate_normal +from sklearn.cluster import KMeans +from tqdm import tqdm + + +class Coreset: + + def __init__( + self, + raw_data: np.ndarray, + number_of_sampling_for_centroids: int, + coreset_size: int, + number_of_coresets_to_evaluate: Optional[int] = 10, + coreset_method: Optional[str] = "BFL2", + k_value_for_BLK2: Optional[int] = 2, + ) -> None: + self._raw_data = raw_data + self._coreset_size = coreset_size + self._number_of_coresets_to_evaluate = number_of_coresets_to_evaluate + self._number_of_sampling_for_centroids = number_of_sampling_for_centroids + self._k_value_for_BLK2 = k_value_for_BLK2 + + if coreset_method not in ["BFL2", "BLK2"]: + raise ValueError("Coreset method must be either BFL2 or BLK2.") + else: + self._coreset_method = coreset_method + + @property + def raw_data(self) -> np.ndarray: + return self._raw_data + + @property + def coreset_size(self) -> int: + return self._coreset_size + + @property + def number_of_coresets_to_evaluate(self) -> int: + return self._number_of_coresets_to_evaluate + + @property + def number_of_sampling_for_centroids(self) -> int: + return self._number_of_sampling_for_centroids + + @property + def coreset_method(self) -> str: + return self._coreset_method + + @property + def k_value_for_BLK2(self) -> int: + return self._k_value_for_BLK2 + + @raw_data.setter + def raw_data(self, raw_data: np.ndarray) -> None: + self._raw_data = raw_data + + @coreset_size.setter + def coreset_size(self, coreset_size: int) -> None: + self._coreset_size = coreset_size + + @number_of_coresets_to_evaluate.setter + def number_of_coresets_to_evaluate( + self, number_of_coresets_to_evaluate: int) -> None: + self._number_of_coresets_to_evaluate = number_of_coresets_to_evaluate + + @number_of_sampling_for_centroids.setter + def number_of_sampling_for_centroids( + self, number_of_sampling_for_centroids: int) -> None: + self._number_of_sampling_for_centroids = number_of_sampling_for_centroids + + @coreset_method.setter + def coreset_method(self, coreset_method: str) -> None: + self._coreset_method = coreset_method + + @k_value_for_BLK2.setter + def k_value_for_BLK2(self, k_value_for_BLK2: int) -> None: + self._k_value_for_BLK2 = k_value_for_BLK2 + + def get_best_coresets(self) -> Tuple[np.ndarray, np.ndarray]: + """ + Get the best coreset vectors and weights for a given data. + + Returns: + `Tuple[np.ndarray, np.ndarray]`: The coreset vectors and weights. + """ + + centroids = self.get_best_centroids() + + if self._coreset_method == "BFL2": + print("Using BFL2 method to generate coresets") + coreset_vectors, coreset_weights = self.get_coresets_using_BFL2( + centroids) + + elif self._coreset_method == "BLK2": + print("Using BLK2 method to generate coresets") + coreset_vectors, coreset_weights = self.get_coresets_using_BLK2( + centroids) + else: + raise ValueError("Coreset method must be either BFL2 or BLK2.") + + coreset_vectors, coreset_weights = self.best_coreset_using_kmeans_cost( + coreset_vectors, coreset_weights) + + self.coreset_vectors = coreset_vectors + self.coreset_weights = coreset_weights + + return (np.array(coreset_vectors), np.array(coreset_weights)) + + def get_coresets_using_BFL2( + self, centroids: List[np.ndarray] + ) -> Tuple[List[np.ndarray], List[np.ndarray]]: + """ + Generates coreset vectors and weights using the BFL2 algorithm. + + Args: + `centroids (List[np.ndarray])`: The centroids to use for the coreset generation. + + Returns: + `Tuple[List[np.ndarray], List[np.ndarray]]`: List of coreset vectors and weights. + """ + + coreset_vectors_list = [] + coreset_weights_list = [] + for i in range(self.number_of_coresets_to_evaluate): + coreset_vectors, coreset_weights = self.BFL2(centroids=centroids) + coreset_vectors_list.append(coreset_vectors) + coreset_weights_list.append(coreset_weights) + + return (coreset_vectors_list, coreset_weights_list) + + def get_best_centroids(self) -> List[np.ndarray]: + """ + Get the best centroids using the D2 sampling algorithm. + + Returns: + List[np.ndarray]: The best centroids. + + """ + + best_centroid_coordinates, best_centroid_cost = None, np.inf + + for _ in range(self.number_of_sampling_for_centroids): + centroids = self.D2_sampling() + cost = self.get_cost(centroids) + if cost < best_centroid_cost: + best_centroid_coordinates, best_centroid_cost = centroids, cost + + return best_centroid_coordinates + + def D2_sampling(self) -> List[np.ndarray]: + """ + Selects the centroids from the data points using the D2 sampling algorithm. + + Returns: + List[np.ndarray]: The selected centroids as a list. + """ + + centroids = [] + data_vectors = self.raw_data + + centroids.append(data_vectors[np.random.choice(len(data_vectors))]) + + for _ in range(self.coreset_size - 1): + p = np.zeros(len(data_vectors)) + for i, x in enumerate(data_vectors): + p[i] = self.distance_to_centroids(x, centroids)[0]**2 + p = p / sum(p) + centroids.append(data_vectors[np.random.choice(len(data_vectors), + p=p)]) + + return centroids + + def get_cost(self, centroids: Union[List[np.ndarray], np.ndarray]) -> float: + """ + Computes the sum of between each data points and each centroids. + + Args: + `centroids (Union[List[np.ndarray], np.ndarray])`: The centroids to evaluate. + + Returns: + float: The cost of the centroids. + + """ + + cost = 0.0 + for x in self.raw_data: + cost += self.distance_to_centroids(x, centroids)[0]**2 + return cost + + def distance_to_centroids( + self, data_instance: np.ndarray, + centroids: Union[List[np.ndarray], + np.ndarray]) -> Tuple[float, int]: + """ + Compute the distance between a data instance and the centroids. + + Args: + `data_instance (np.ndarray)`: The data instance. + `centroids (Union[List[np.ndarray], np.ndarray])`: The centroids as a list or `numpy` array. + + Returns: + Tuple[float, int]: The minimum distance and the index of the closest centroid. + """ + + minimum_distance = np.inf + closest_index = -1 + for i, centroid in enumerate(centroids): + distance_between_data_instance_and_centroid = np.linalg.norm( + data_instance - centroid) + if distance_between_data_instance_and_centroid < minimum_distance: + minimum_distance = distance_between_data_instance_and_centroid + closest_index = i + + return (minimum_distance, closest_index) + + def BFL2( + self, centroids: Union[List[np.ndarray], np.ndarray] + ) -> Tuple[List[np.ndarray], List[float]]: + """ + Performs Algorithm 2 from https://arxiv.org/pdf/1612.00889.pdf BFL2. This will pick the coreset vectors and its corresponding weights. + + Args: + centroids (List): The centroids to use for the coreset generation. + + Returns: + Tuple[List, List]: The coreset vectors and coreset weights. + """ + + number_of_data_points_close_to_a_cluster = { + i: 0 for i in range(len(centroids)) + } + sum_distance_to_closest_cluster = 0.0 + for data_instance in self.raw_data: + min_dist, closest_index = self.distance_to_centroids( + data_instance, centroids) + number_of_data_points_close_to_a_cluster[closest_index] += 1 + sum_distance_to_closest_cluster += min_dist**2 + + Prob = np.zeros(len(self._raw_data)) + for i, p in enumerate(self._raw_data): + min_dist, closest_index = self.distance_to_centroids(p, centroids) + Prob[i] += min_dist**2 / (2 * sum_distance_to_closest_cluster) + Prob[i] += 1 / ( + 2 * len(centroids) * + number_of_data_points_close_to_a_cluster[closest_index]) + + if not (0.999 <= sum(Prob) <= 1.001): + raise ValueError( + "sum(Prob) = %s; the algorithm should automatically " + "normalize Prob by construction" % sum(Prob)) + chosen_indices = np.random.choice(len(self._raw_data), + size=self._coreset_size, + p=Prob) + weights = [1 / (self._coreset_size * Prob[i]) for i in chosen_indices] + + return ([self._raw_data[i] for i in chosen_indices], weights) + + def kmeans_cost(self, + coreset_vectors: np.ndarray, + sample_weight: Optional[np.ndarray] = None) -> float: + """ + Compute the cost of coreset vectors using k-means clustering. + + Args: + `coreset_vectors (np.ndarray)`: The coreset vectors. + `sample_weight (np.ndarray)`: The sample weights. + + Returns: + float: The cost of the k-means clustering. + + """ + + kmeans = KMeans(n_clusters=2).fit(coreset_vectors, + sample_weight=sample_weight) + return self.get_cost(kmeans.cluster_centers_) + + def best_coreset_using_kmeans_cost( + self, coreset_vectors: List[np.ndarray], + coreset_weights: List[np.ndarray]) -> Tuple[np.ndarray, np.ndarray]: + """ + Get the best coreset using k-means cost. + + Args: + `coreset_vectors (List[np.ndarray])`: The coreset vectors. + `coreset_weights (List[np.ndarray])`: The coreset weights. + + Returns: + Tuple: The best coreset vectors and coreset weights. + """ + + cost_coreset = [ + self.kmeans_cost( + coreset_vectors=coreset_vectors[i], + sample_weight=coreset_weights[i], + ) for i in range(self._number_of_coresets_to_evaluate) + ] + + best_index = cost_coreset.index(np.min(cost_coreset)) + return (coreset_vectors[best_index], coreset_weights[best_index]) + + def get_coresets_using_BLK2( + self, centroids: Union[List[np.ndarray], np.ndarray] + ) -> Tuple[List[List[np.ndarray]], List[List[float]]]: + """ + Generates coreset vectors and weights using Algorithm 2. + + Args: + `centroids (List[np.ndarray])`: The centroids to use for the coreset generation. + + Returns: + `Tuple[List[List[np.ndarray]], List[List[float]]]`: The coreset vectors and coreset weights. + """ + + coreset_vectors_list = [] + coreset_weights_list = [] + for i in range(self.number_of_coresets_to_evaluate): + coreset_vectors, coreset_weights = self.BLK2(centroids=centroids) + coreset_vectors_list.append(coreset_vectors) + coreset_weights_list.append(coreset_weights) + + return (coreset_vectors_list, coreset_weights_list) + + def BLK2( + self, + centroids: Union[List[np.ndarray], np.ndarray], + ) -> Tuple[List[np.ndarray], List[float]]: + """ + Performs Algorithm 2 from https://arxiv.org/pdf/1703.06476.pdf. + + Args: + `centroids (List[np.ndarray])`: The centroids to use for the coreset generation. + + Returns: + `Tuple[List, List]`: The coreset vectors and coreset weights. + """ + + alpha = 16 * (np.log2(self._k_value_for_BLK2) + 2) + + B_i_totals = [0] * len(centroids) + B_i = [np.empty_like(self._raw_data) for _ in range(len(centroids))] + for data_instance in self._raw_data: + _, closest_index = self.distance_to_centroids( + data_instance, centroids) + B_i[closest_index][B_i_totals[closest_index]] = data_instance + B_i_totals[closest_index] += 1 + + c_phi = sum([ + self.distance_to_centroids(data_instance, centroids)[0]**2 + for data_instance in self._raw_data + ]) / len(self._raw_data) + + p = np.zeros(len(self._raw_data)) + + sum_dist = {i: 0.0 for i in range(len(centroids))} + for i, data_instance in enumerate(self._raw_data): + dist, closest_index = self.distance_to_centroids( + data_instance, centroids) + sum_dist[closest_index] += dist**2 + + for i, data_instance in enumerate(self._raw_data): + p[i] = 2 * alpha * self.distance_to_centroids( + data_instance, centroids)[0]**2 / c_phi + + closest_index = self.distance_to_centroids(data_instance, + centroids)[1] + p[i] += 4 * alpha * sum_dist[closest_index] / ( + B_i_totals[closest_index] * c_phi) + + p[i] += 4 * len(self._raw_data) / B_i_totals[closest_index] + p = p / sum(p) + + chosen_indices = np.random.choice(len(self._raw_data), + size=self._coreset_size, + p=p) + weights = [1 / (self._coreset_size * p[i]) for i in chosen_indices] + + return [self._raw_data[i] for i in chosen_indices], weights + + @staticmethod + def coreset_to_graph( + coreset_vectors: np.ndarray, + coreset_weights: np.ndarray, + metric: Optional[str] = "dot", + number_of_qubits_representing_data: Optional[int] = 1, + ) -> nx.Graph: + """ + Convert coreset vectors to a graph. + + Args: + `coreset_vectors (np.ndarray)`: The coreset vectors. + `coreset_weights (np.ndarray)`: The coreset weights. + `metric (str, optional)`: The metric to use. Defaults to "dot". + `number_of_qubits_representing_data (int, optional)`: The number of qubits representing the data. Defaults to 1. + + Returns: + `nx.Graph`: The graph. + """ + + coreset = [(w, v) for w, v in zip(coreset_weights, coreset_vectors)] + + vertices = len(coreset) + vertex_labels = [ + number_of_qubits_representing_data * int(i) for i in range(vertices) + ] + G = nx.Graph() + G.add_nodes_from(vertex_labels) + edges = [( + number_of_qubits_representing_data * i, + number_of_qubits_representing_data * j, + ) for i in range(vertices) for j in range(i + 1, vertices)] + + G.add_edges_from(edges) + + for edge in G.edges(): + v_i = edge[0] // number_of_qubits_representing_data + v_j = edge[1] // number_of_qubits_representing_data + w_i = coreset[v_i][0] + w_j = coreset[v_j][0] + if metric == "dot": + mval = np.dot( + coreset[v_i][1], + coreset[v_j][1], + ) + elif metric == "dist": + mval = np.linalg.norm(coreset[v_i][1] - coreset[v_j][1]) + else: + raise Exception("Unknown metric: {}".format(metric)) + + G[edge[0]][edge[1]]["weight"] = w_i * w_j * mval + + return G + + @staticmethod + def normalize_array(vectors: np.ndarray, + centralize: bool = False) -> np.ndarray: + """ + Normalize and centralize the array + + Args: + `vectors (np.ndarray)`: The vectors to normalize + `centralize (bool, optional)`: Centralize the array. Defaults to False. + + Returns: + `np.ndarray`: The normalized array + """ + + if centralize: + vectors = vectors - np.mean(vectors, axis=0) + + max_abs = np.max(np.abs(vectors), axis=0) + vectors_norm = vectors / max_abs + + return vectors_norm + + @staticmethod + def create_dataset( + n_samples: float, + covariance_values: List[float] = [-0.8, -0.8], + n_features: Optional[int] = 2, + number_of_samples_from_distribution: Optional[int] = 500, + mean_array: Optional[np.ndarray] = np.array([[0, 0], [7, 1]]), + random_seed: Optional[int] = 10, + ) -> np.ndarray: + """ + Create a data set with the given parameters. + + Args: + `n_samples (float)`: The number of samples. + `covariance_values (List[float], optional)`: The covariance values. Defaults to [-0.8, -0.8]. + `n_features (int, optional)`: The number of features. Defaults to 2. + `number_of_samples_from_distribution (int, optional)`: The number of samples from the distribution. Defaults to 500. + `mean_array (np.ndarray, optional)`: The mean array. Defaults to `np.array([[0, 0], [7, 1]])`. + `random_seed (int, optional)`: The random seed. Defaults to 10. + + Returns: + `np.ndarray`: The data set created + """ + + random_seed = random_seed + + X = np.zeros((n_samples, n_features)) + + for idx, val in enumerate(covariance_values): + covariance_matrix = np.array([[1, val], [val, 1]]) + + distr = multivariate_normal(cov=covariance_matrix, + mean=mean_array[idx], + seed=random_seed) + + data = distr.rvs(size=number_of_samples_from_distribution) + + X[number_of_samples_from_distribution * + idx:number_of_samples_from_distribution * (idx + 1)][:] = data + + return X + + +class DivisiveClustering(ABC): + + def __init__( + self, + circuit_depth: int, + max_iterations: int, + max_shots: int, + threshold_for_max_cut: float, + create_Hamiltonian: Callable, + optimizer: cudaq.optimizers.optimizer, + optimizer_function: Callable, + create_circuit: Callable, + normalize_vectors: Optional[bool] = True, + sort_by_descending: Optional[bool] = True, + coreset_to_graph_metric: Optional[str] = "dot", + ) -> None: + self.circuit_depth = circuit_depth + self.max_iterations = max_iterations + self.max_shots = max_shots + self.threshold_for_maxcut = threshold_for_max_cut + self.normalize_vectors = normalize_vectors + self.sort_by_descending = sort_by_descending + self.coreset_to_graph_metric = coreset_to_graph_metric + self.create_Hamiltonian = create_Hamiltonian + self.create_circuit = create_circuit + self.optimizer = optimizer + self.optimizer_function = optimizer_function + + @abstractmethod + def run_divisive_clustering( + self, coreset_vectors_df_for_iteration: pd.DataFrame + ) -> Union[List[str], List[int]]: + """ + Run the divisive clustering algorithm. + + Args: + `coreset_vectors_df_for_iteration (pd.DataFrame)`: The coreset vectors for the iteration. + + Returns: + `Union[List[str], List[int]]`: The bitstring or the cluster. The return will depend on the name of the data point given. + """ + + pass + + def get_hierarchical_clustering_sequence( + self, + coreset_vectors_df_for_iteration: np.ndarray, + hierarchial_sequence: List, + ) -> List: + """ + Get the hierarchical clustering sequence. + + Args: + `coreset_vectors_df_for_iteration (np.ndarray)`: The coreset vectors for the iteration. + `hierarchial_sequence (List)`: The hierarchical sequence. + + """ + + bitstring = self.run_divisive_clustering( + coreset_vectors_df_for_iteration) + return self._add_children_to_hierarchial_clustering( + coreset_vectors_df_for_iteration, hierarchial_sequence, bitstring) + + def _get_iteration_coreset_vectors_and_weights( + self, coreset_vectors_df_for_iteration: pd.DataFrame + ) -> Tuple[np.ndarray, np.ndarray]: + """ + Gets the iteration coreset vectors and weights. + + Args: + `coreset_vectors_df_for_iteration (pd.DataFrame)`: The coreset vectors for the iteration. + + Returns: + `Tuple[np.ndarray, np.ndarray]`: The coreset vectors and weights. + + """ + + coreset_vectors_for_iteration = coreset_vectors_df_for_iteration[[ + "X", "Y" + ]].to_numpy() + + coreset_weights_for_iteration = coreset_vectors_df_for_iteration[ + "weights"].to_numpy() + + if self.normalize_vectors: + coreset_vectors_for_iteration = Coreset.normalize_array( + coreset_vectors_for_iteration, True) + coreset_weights_for_iteration = Coreset.normalize_array( + coreset_weights_for_iteration) + + return (coreset_vectors_for_iteration, coreset_weights_for_iteration) + + def brute_force_cost_maxcut(self, bitstrings: list[Union[str, int]], + G: nx.graph) -> Dict[str, float]: + """ + Cost function for brute force method + + Args: + bitstrings: list of bit strings + G: The graph of the problem + + Returns: + Dict: Dictionary with bitstring and cost value + """ + + cost_value = {} + for bitstring in tqdm(bitstrings): + c = 0 + for i, j in G.edges(): + edge_weight = G[i][j]["weight"] + c += self._get_edge_cost(bitstring, i, j, edge_weight) + + cost_value.update({bitstring: c}) + + return cost_value + + def _get_edge_cost(self, bitstring: str, i: int, j: int, + edge_weight: float) -> float: + """ + Get the edge cost using MaxCut cost function. + + Args: + bitstring: The bitstring + i: The first node + j: The second node + edge_weight: The edge weight + + Returns: + float: The edge cost + """ + + ai = int(bitstring[i]) + aj = int(bitstring[j]) + + return -1 * edge_weight * (1 - ((-1)**ai) * ((-1)**aj)) + + def _add_children_to_hierarchial_clustering( + self, + iteration_dataframe: pd.DataFrame, + hierarchial_sequence: list, + bitstring: str, + ) -> List[Union[str, int]]: + """ + Add children to the hierarchical clustering sequence. + + Args: + `iteration_dataframe (pd.DataFrame)`: The iteration data frame. + `hierarchial_sequence (list)`: The hierarchical sequence. + `bitstring (str)`: The bitstring. + + Returns: + list: The hierarchical sequence. + """ + + iteration_dataframe["cluster"] = [int(bit) for bit in bitstring] + + for j in range(2): + idx = list( + iteration_dataframe[iteration_dataframe["cluster"] == j].index) + if len(idx) > 0: + hierarchial_sequence.append(idx) + + return hierarchial_sequence + + @staticmethod + def get_divisive_cluster_cost(hierarchical_clustering_sequence: List[Union[ + str, int]], coreset_data: pd.DataFrame) -> List[float]: + """ + Get the cost of the divisive clustering at each iteration. + + Args: + `hierarchical_clustering_sequence (List)`: The hierarchical clustering sequence. + `coreset_data (pd.DataFrame)`: The coreset data. + + Returns: + List[float]: The cost of the divisive clustering sequence. + """ + + coreset_data = coreset_data.drop(["Name", "weights"], axis=1) + cost_at_each_iteration = [] + for parent in hierarchical_clustering_sequence: + children_lst = Dendrogram.find_children( + parent, hierarchical_clustering_sequence) + + if not children_lst: + continue + else: + children_1, children_2 = children_lst + + parent_data_frame = coreset_data.iloc[parent] + + parent_data_frame["cluster"] = 0 + + parent_data_frame.loc[children_2, "cluster"] = 1 + + cost = 0 + + centroid_coords = parent_data_frame.groupby("cluster").mean()[[ + "X", "Y" + ]] + centroid_coords = centroid_coords.to_numpy() + + for idx, row in parent_data_frame.iterrows(): + if row.cluster == 0: + cost += np.linalg.norm(row[["X", "Y"]] - + centroid_coords[0])**2 + else: + cost += np.linalg.norm(row[["X", "Y"]] - + centroid_coords[1])**2 + + cost_at_each_iteration.append(cost) + + return cost_at_each_iteration + + def _get_best_bitstring(self, counts: cudaq.SampleResult, + G: nx.Graph) -> str: + """ + From the simulator output, extract the best bitstring. + + Args: + `counts (cudaq.SampleResult)`: The counts. + `G (nx.Graph)`: The graph. + + Returns: + `str`: The best bitstring. + """ + + counts_pd = pd.DataFrame(counts.items(), + columns=["bitstring", "counts"]) + counts_pd[ + "probability"] = counts_pd["counts"] / counts_pd["counts"].sum() + bitstring_probability_df = counts_pd.drop(columns=["counts"]) + bitstring_probability_df = bitstring_probability_df.sort_values( + "probability", ascending=self.sort_by_descending) + + unacceptable_bitstrings = [ + "".join("1" for _ in range(10)), + "".join("0" for _ in range(10)), + ] + + bitstring_probability_df = bitstring_probability_df[ + ~bitstring_probability_df["bitstring"].isin(unacceptable_bitstrings + )] + + if len(bitstring_probability_df) > 10: + selected_rows = int( + len(bitstring_probability_df) * self.threshold_for_maxcut) + else: + selected_rows = int(len(bitstring_probability_df) / 2) + + bitstring_probability_df = bitstring_probability_df.head(selected_rows) + + bitstrings = bitstring_probability_df["bitstring"].tolist() + + brute_force_cost_of_bitstrings = self.brute_force_cost_maxcut( + bitstrings, G) + + return min(brute_force_cost_of_bitstrings, + key=brute_force_cost_of_bitstrings.get) + + def get_divisive_sequence( + self, full_coreset_df: pd.DataFrame) -> List[Union[str, int]]: + """ + Perform divisive clustering on the coreset data. + + Args: + `full_coreset_df (pd.DataFrame)`: The full coreset data. + + Returns: + `List[Union[str, int]]`: The hierarchical clustering sequence. + """ + + index_iteration_counter = 0 + single_clusters = 0 + + index_values = list(range(len(full_coreset_df))) + hierarchical_clustering_sequence = [index_values] + + while single_clusters < len(index_values): + index_values_to_evaluate = hierarchical_clustering_sequence[ + index_iteration_counter] + if len(index_values_to_evaluate) == 1: + single_clusters += 1 + + elif len(index_values_to_evaluate) == 2: + hierarchical_clustering_sequence.append( + [index_values_to_evaluate[0]]) + hierarchical_clustering_sequence.append( + [index_values_to_evaluate[1]]) + + else: + coreset_vectors_df_for_iteration = full_coreset_df.iloc[ + index_values_to_evaluate] + + hierarchical_clustering_sequence = self.get_hierarchical_clustering_sequence( + coreset_vectors_df_for_iteration, + hierarchical_clustering_sequence, + ) + + index_iteration_counter += 1 + + return hierarchical_clustering_sequence + + +class Dendrogram: + + def __init__( + self, coreset_data: pd.DataFrame, + hierarchical_clustering_sequence: List[Union[str, int]]) -> None: + self._coreset_data = self.__create_coreset_data(coreset_data) + self._hierarchial_clustering_sequence = self.__convert_numbers_to_name( + hierarchical_clustering_sequence, coreset_data) + self.linkage_matrix = [] + + @property + def coreset_data(self) -> pd.DataFrame: + return self._coreset_data + + @coreset_data.setter + def coreset_data(self, coreset_data: pd.DataFrame) -> None: + self.linkage_matrix = [] + self._coreset_data = coreset_data + + @property + def hierarchical_clustering_sequence(self) -> List[Union[str, int]]: + return self._hierarchial_clustering_sequence + + @hierarchical_clustering_sequence.setter + def hierarchical_clustering_sequence( + self, hierarchical_clustering_sequence: List[Union[str, + int]]) -> None: + self.linkage_matrix = [] + self._hierarchial_clustering_sequence = hierarchical_clustering_sequence + + def __call__(self) -> List: + if not self.linkage_matrix: + self.get_linkage_matrix(self._hierarchial_clustering_sequence[0]) + + return self.linkage_matrix + + def __create_coreset_data(self, coreset_data: pd.DataFrame) -> pd.DataFrame: + """ + Creates coreset data that can be used for plotting. + + Args: + `coreset_data (pd.DataFrame)`: The coreset data. + + Returns: + `pd.DataFrame`: The coreset data. + """ + + _coreset_data = coreset_data.copy() + _coreset_data.index = _coreset_data.Name + + return _coreset_data.drop(columns=["Name", "weights"]) + + def __convert_numbers_to_name(self, + hierarchical_clustering_sequence: List[int], + coreset_data: pd.DataFrame) -> List[str]: + """ + Converts the int in the hierarchical sequence into the instance name. This would be used to plot the leaves of the dendrogram. + + Args: + `hierarchical_clustering_sequence (List[int])`: The hierarchical clustering sequence. + `coreset_data (pd.DataFrame)`: The coreset data. + + Returns: + List[str]: The converted hierarchical clustering sequence. + """ + + converted_hc = [] + for hc in hierarchical_clustering_sequence: + converted_hc.append([coreset_data.Name[num] for num in hc]) + + return converted_hc + + def plot_dendrogram( + self, + plot_title: Optional[str] = "DIANA", + orientation: Optional[str] = "top", + color_threshold: Optional[int] = None, + colors: Optional[List] = None, + clusters: Optional[np.ndarray] = None, + link_color_func: Optional[Callable] = None, + ): + """ + Plots the dendrogram. + + Args: + `plot_title (str, optional)`: The plot title. Defaults to "DIANA". + `orientation (str, optional)`: The orientation of the dendrogram. Defaults to "top". + `color_threshold (int, optional)`: The color threshold to convert hierarchical clustering into flat clustering. Defaults to None. + `colors (List, optional)`: The colors for the leaves. Defaults to None. + `clusters (np.ndarray, optional)`: Flat clustering results from applying threshold. Defaults to None. + `link_color_func (Callable, optional)`: Function to color the branches. Defaults to None. + """ + + if not self.linkage_matrix: + self.get_linkage_matrix(self._hierarchial_clustering_sequence[0]) + + if clusters is None: + clusters = np.array([0] * len(self._coreset_data)) + + fig = plt.figure(figsize=(10, 10), dpi=100) + plt.title(plot_title) + dn = dendrogram( + self.linkage_matrix, + labels=self._coreset_data.index, + orientation=orientation, + color_threshold=color_threshold * 100 if colors else None, + ) + + if color_threshold is not None: + plt.axhline(y=color_threshold, color="r", linestyle="--") + + if colors is not None: + if len(colors) < len(set(clusters)): + raise ValueError( + "Number of colors should be equal to number of clusters") + else: + colors_dict = { + self._coreset_data.index[i]: colors[j] + for i, j in enumerate(clusters) + } + + ax = plt.gca() + xlbls = ax.get_xmajorticklabels() + for lbl in xlbls: + lbl.set_color(colors_dict[lbl.get_text()]) + + plt.show() + + def get_clusters_using_height(self, threshold: float) -> np.ndarray: + """ + Get flat clusters from the hierarchical clustering using a threshold. + + Args: + threshold (float): The height threshold to convert. + + Returns: + `np.ndarray`: The flat cluster labels. + """ + + if not self.linkage_matrix: + self.get_linkage_matrix(self._hierarchial_clustering_sequence[0]) + + clusters = fcluster(self.linkage_matrix, + threshold, + criterion="distance") + + return np.array(clusters) - 1 + + def get_clusters_using_k(self, k: int) -> np.ndarray: + """ + Get flat clusters from the hierarchical cluster by defining the number of clusters. + + Args: + k (int): The number of clusters. + + Returns: + `np.ndarray`: The flat cluster labels. + + """ + if not self.linkage_matrix: + self.get_linkage_matrix(self._hierarchial_clustering_sequence[0]) + + clusters = fcluster(self.linkage_matrix, k, criterion="maxclust") + + return np.array(clusters) - 1 + + def plot_clusters( + self, + clusters: np.ndarray, + colors: List[str], + plot_title: str, + show_annotation: Optional[bool] = False, + ): + """ + Plot the flat clusters. + + Args: + `clusters (np.ndarray)`: The flat clusters. + `colors (List[str])`: The colors for the clusters. + `plot_title (str)`: The plot title. + `show_annotation (bool, optional)`: Show annotation. Defaults to False. + + """ + if len(colors) < len(set(clusters)): + raise ValueError( + "Number of colors should be equal to number of clusters") + coreset_data = self._coreset_data.copy() + coreset_data["clusters"] = clusters + for i in range(coreset_data.clusters.nunique()): + data = coreset_data[coreset_data.clusters == i] + plt.scatter(data.X, data.Y, c=colors[i], label=f"Cluster {i}") + if show_annotation: + for _, row in coreset_data.iterrows(): + plt.annotate(row.name, (row.X, row.Y)) + plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left") + plt.title(plot_title) + plt.show() + + def get_linkage_matrix(self, parent: List[str]) -> int: + """ + Create the linkage matrix for the dendrogram and returns the index of the new branch. + + Args: + parent (`List[str]`): The parent cluster. + + Returns: + List: The linkage matrix. + """ + + if len(parent) < 2: + index_of_parent = np.argwhere(self._coreset_data.index == parent[0]) + return index_of_parent[0][0] + children_1, children_2 = self.find_children( + parent, self._hierarchial_clustering_sequence) + + index1 = self.get_linkage_matrix(children_1) + index2 = self.get_linkage_matrix(children_2) + self.linkage_matrix.append([ + index1, + index2, + self.distance(index1) + self.distance(index2), + self.cluster_len(index1) + self.cluster_len(index2), + ]) + + return len(self.linkage_matrix) - 1 + len(self.coreset_data) + + def distance(self, i: int) -> float: + """ + Get the distance between two clusters. + + Args: + i (int): The index of the cluster. + + Returns: + float: The distance of the cluster. + """ + + if i >= len(self._coreset_data): + distance = self.linkage_matrix[i - len(self._coreset_data)][2] + else: + distance = sum( + self._coreset_data.iloc[i]) / (len(self.coreset_data) - 1) + + return abs(distance) + + def cluster_len(self, i: int): + """ + Get the length of the cluster. + + Args: + i (int): The index of the cluster. + + Returns: + int: The length of the cluster. + """ + + if i >= len(self._coreset_data): + return self.linkage_matrix[i - len(self._coreset_data)][3] + else: + return 1 + + @staticmethod + def find_children( + parent: List[Union[str, int]], + hierarchical_clustering_sequence: List[Union[str, int]]) -> List: + """ + Find the children of a given parent cluster. + + Args: + parent (List): The parent cluster. + hierarchical_clustering_sequence (List): The hierarchical clustering sequence. + + Returns: + List: The children of the parent cluster. + """ + + parent_position = hierarchical_clustering_sequence.index(parent) + + found = 0 + children = [] + for i in range(parent_position + 1, + len(hierarchical_clustering_sequence)): + if any(item in hierarchical_clustering_sequence[i] + for item in parent): + children.append(hierarchical_clustering_sequence[i]) + found += 1 + if found == 2: + break + + return children + + @staticmethod + def plot_hierarchial_split( + hierarchical_clustering_sequence: List[Union[str, int]], + full_coreset_df: pd.DataFrame): + """ + Plots the flat clusters at each iteration of the hierarchical clustering. + + Args: + hierarchical_clustering_sequence (List): The hierarchical clustering sequence. + `full_coreset_df` (`pd.DataFrame`): The full coreset data. + """ + parent_clusters = [ + parent_cluster + for parent_cluster in hierarchical_clustering_sequence + if len(parent_cluster) > 1 + ] + x_grid = int(np.sqrt(len(parent_clusters))) + y_grid = int(np.ceil(len(parent_clusters) / x_grid)) + + fig, axs = plt.subplots(x_grid, y_grid, figsize=(12, 12)) + + for i, parent_cluster in enumerate(parent_clusters): + parent_position = hierarchical_clustering_sequence.index( + parent_cluster) + children = Dendrogram.find_children( + parent_cluster, hierarchical_clustering_sequence) + coreset_for_parent_cluster = full_coreset_df.loc[parent_cluster] + coreset_for_parent_cluster["cluster"] = 1 + coreset_for_parent_cluster.loc[children[0], "cluster"] = 0 + + ax = axs[i // 3, i % 3] + ax.scatter( + coreset_for_parent_cluster["X"], + coreset_for_parent_cluster["Y"], + c=coreset_for_parent_cluster["cluster"], + ) + for _, row in coreset_for_parent_cluster.iterrows(): + ax.annotate(row["Name"], (row["X"], row["Y"])) + + ax.set_xlabel("X") + ax.set_ylabel("Y") + ax.set_title(f"Clustering at iteration {parent_position}") + + plt.tight_layout() + plt.show() + + +class Voironi_Tessalation: + + def __init__( + self, + coreset_df: pd.DataFrame, + clusters: np.ndarray, + colors: List[str], + tesslation_by_cluster: Optional[bool] = False, + ) -> None: + coreset_df["cluster"] = clusters + + if tesslation_by_cluster: + cluster_means = coreset_df.groupby("cluster")[["X", "Y"]].mean() + coreset_df = cluster_means.reset_index() + coreset_df["cluster"] = [i for i in range(len(coreset_df))] + + coreset_df["color"] = [colors[i] for i in coreset_df.cluster] + + points = coreset_df[["X", "Y"]].to_numpy() + + self.coreset_df = coreset_df + + self.voronoi = Voronoi(points) + + def voronoi_finite_polygons_2d(self, + radius: Optional[float] = None + ) -> Tuple[List, np.ndarray]: + """ + Creates the Voronoi regions and vertices for 2D data. + + Args: + radius (Optional[None]): The radius from the data points to create the Voronoi regions. Defaults to None. + + Returns: + Tuple: The regions and vertices. + """ + + if self.voronoi.points.shape[1] != 2: + raise ValueError("Requires 2D input") + + new_regions = [] + new_vertices = self.voronoi.vertices.tolist() + + center = self.voronoi.points.mean(axis=0) + if radius is None: + radius = self.voronoi.points.ptp().max() + + all_ridges = {} + for (p1, p2), (v1, v2) in zip(self.voronoi.ridge_points, + self.voronoi.ridge_vertices): + all_ridges.setdefault(p1, []).append((p2, v1, v2)) + all_ridges.setdefault(p2, []).append((p1, v1, v2)) + + for p1, region in enumerate(self.voronoi.point_region): + vertices = self.voronoi.regions[region] + + if all(v >= 0 for v in vertices): + new_regions.append(vertices) + continue + + ridges = all_ridges[p1] + new_region = [v for v in vertices if v >= 0] + + for p2, v1, v2 in ridges: + if v2 < 0: + v1, v2 = v2, v1 + if v1 >= 0: + continue + + t = self.voronoi.points[p2] - self.voronoi.points[p1] + t /= np.linalg.norm(t) + n = np.array([-t[1], t[0]]) + + midpoint = self.voronoi.points[[p1, p2]].mean(axis=0) + direction = np.sign(np.dot(midpoint - center, n)) * n + + far_point = self.voronoi.vertices[v2] + direction * radius + + new_region.append(len(new_vertices)) + new_vertices.append(far_point.tolist()) + + vs = np.asarray([new_vertices[v] for v in new_region]) + c = vs.mean(axis=0) + + angles = np.arctan2(vs[:, 1] - c[1], vs[:, 0] - c[0]) + new_region = np.array(new_region)[np.argsort(angles)] + + new_regions.append(new_region.tolist()) + + return new_regions, np.asarray(new_vertices) + + def plot_voironi( + self, + plot_title: Optional[str] = "Voronoi Tessalation", + show_annotation: bool = False, + show_scatters: bool = False, + ): + regions, vertices = self.voronoi_finite_polygons_2d() + fig, ax = plt.subplots(figsize=(8, 8)) + fig.tight_layout(pad=10) + + for j, region in enumerate(regions): + polygon = vertices[region] + color = self.coreset_df.color[j] + breakpoint() + plt.fill(*zip(*polygon), alpha=0.4, color=color, linewidth=0) + if show_annotation: + plt.annotate( + self.coreset_df.Name[j], + (self.coreset_df.X[j] + 0.2, self.coreset_df.Y[j]), + fontsize=10, + ) + + if show_scatters: + plt.plot(self.coreset_df.X, self.coreset_df.Y, "ko") + + plt.xlim(min(self.coreset_df.X) - 1, max(self.coreset_df.X) + 1) + plt.ylim(min(self.coreset_df.Y) - 1, max(self.coreset_df.Y) + 1) + plt.xlabel("x") + plt.ylabel("y") + plt.title(plot_title) + plt.show() diff --git a/pr-2023/sphinx/examples/python/tutorials/divisive_clustering_src/main_divisive_clustering.py b/pr-2023/sphinx/examples/python/tutorials/divisive_clustering_src/main_divisive_clustering.py new file mode 100644 index 0000000000..e9869e0d1c --- /dev/null +++ b/pr-2023/sphinx/examples/python/tutorials/divisive_clustering_src/main_divisive_clustering.py @@ -0,0 +1,259 @@ +import argparse +import os +import sys +import time +import warnings +from typing import Callable + +import cudaq +import networkx as nx +import numpy as np +import pandas as pd +from cudaq import spin +from mpi4py import MPI + +sys.path.append(os.path.join(os.path.dirname(__file__), "..")) + +from divisive_clustering import Coreset, DivisiveClustering + +warnings.filterwarnings("ignore") + +argparser = argparse.ArgumentParser() +argparser.add_argument( + "-t", + "--target", + type=str, + choices=["qpp-cpu", "nvidia", "nvidia-mgpu"], + help= + "Quantum simulator backend. Default is qpp-cpu. See https://nvidia.github.io/cuda-quantum/0.6.0/using/simulators.html for more options.", +) +argparser.add_argument( + "-d", + "--depth", + type=int, + default=1, + help="Depth of the QAOA circuit. Default is 1.", +) +argparser.add_argument("-i", + "--max_iterations", + type=int, + default=75, + help="Max iterations for the optimizer.") +argparser.add_argument("-s", + "--max_shots", + type=int, + default=100000, + help="Max shots for the simulation.") +argparser.add_argument("-m", + "--M", + type=int, + default=10, + help="Size of the coreset.") + +args = argparser.parse_args() + +target = args.target +coreset_size = args.M +circuit_depth = args.depth +max_iterations = args.max_iterations +max_shots = args.max_shots + + +class DivisiveClusteringVQA(DivisiveClustering): + + def __init__( + self, + circuit_depth: int, + max_iterations: int, + max_shots: int, + threshold_for_max_cut: float, + create_Hamiltonian: Callable, + optimizer: cudaq.optimizers.optimizer, + optimizer_function: Callable, + create_circuit: Callable, + normalize_vectors: bool = True, + sort_by_descending: bool = True, + coreset_to_graph_metric: str = "dist", + ) -> None: + self.circuit_depth = circuit_depth + self.max_iterations = max_iterations + self.max_shots = max_shots + self.threshold_for_maxcut = threshold_for_max_cut + self.normalize_vectors = normalize_vectors + self.sort_by_descending = sort_by_descending + self.coreset_to_graph_metric = coreset_to_graph_metric + self.create_Hamiltonian = create_Hamiltonian + self.create_circuit = create_circuit + self.optimizer = optimizer + self.optimizer_function = optimizer_function + self.time_consumed = 0 + + def run_divisive_clustering( + self, + coreset_vectors_df_for_iteration: pd.DataFrame, + ): + coreset_vectors_for_iteration_np, coreset_weights_for_iteration_np = ( + self._get_iteration_coreset_vectors_and_weights( + coreset_vectors_df_for_iteration)) + + G = Coreset.coreset_to_graph( + coreset_vectors_for_iteration_np, + coreset_weights_for_iteration_np, + metric=self.coreset_to_graph_metric, + ) + + counts = self.get_counts_from_simulation( + G, + self.circuit_depth, + self.max_iterations, + self.max_shots, + ) + + return self._get_best_bitstring(counts, G) + + def get_counts_from_simulation(self, G, circuit_depth, max_iterations, + max_shots): + qubits = len(G.nodes) + Hamiltonian = self.create_Hamiltonian(G) + optimizer, parameter_count, initial_params = self.optimizer_function( + self.optimizer, + max_iterations, + qubits=qubits, + circuit_depth=circuit_depth) + + kernel = self.create_circuit(qubits, circuit_depth) + + def objective_function(parameter_vector: list[float], + hamiltonian=Hamiltonian, + kernel=kernel) -> tuple[float, list[float]]: + get_result = lambda parameter_vector: cudaq.observe( + kernel, hamiltonian, parameter_vector, qubits, circuit_depth + ).expectation() + + cost = get_result(parameter_vector) + + return cost + + t0 = time.process_time() + + energy, optimal_parameters = optimizer.optimize( + dimensions=parameter_count, function=objective_function) + + counts = cudaq.sample( + kernel, + optimal_parameters, + qubits, + circuit_depth, + shots_count=max_shots, + ) + + tf = time.process_time() + self.time_consumed += tf - t0 + + return counts + + +def get_K2_Hamiltonian(G: nx.Graph) -> cudaq.SpinOperator: + H = 0 + + for i, j in G.edges(): + weight = G[i][j]["weight"] + H += weight * (spin.z(i) * spin.z(j)) + + return H + + +def get_QAOA_circuit(number_of_qubits, circuit_depth): + + @cudaq.kernel + def kernel(thetas: list[float], number_of_qubits: int, circuit_depth: int): + qubits = cudaq.qvector(number_of_qubits) + + layers = circuit_depth + + for layer in range(layers): + for qubit in range(number_of_qubits): + cx(qubits[qubit], qubits[(qubit + 1) % number_of_qubits]) + rz(2.0 * thetas[layer], qubits[(qubit + 1) % number_of_qubits]) + cx(qubits[qubit], qubits[(qubit + 1) % number_of_qubits]) + + rx(2.0 * thetas[layer + layers], qubits) + + return kernel + + +def get_optimizer(optimizer: cudaq.optimizers.optimizer, max_iterations, + **kwargs): + parameter_count = 4 * kwargs["circuit_depth"] * kwargs["qubits"] + initial_params = np.random.uniform(-np.pi / 8.0, np.pi / 8.0, + parameter_count) + optimizer.initial_parameters = initial_params + + optimizer.max_iterations = max_iterations + return optimizer, parameter_count, initial_params + + +def create_coreset_df( + raw_data_size: int = 1000, + number_of_sampling_for_centroids: int = 10, + coreset_size: int = 10, + number_of_coresets_to_evaluate: int = 4, + coreset_method: str = "BFL2", +): + raw_data = Coreset.create_dataset(raw_data_size) + coreset = Coreset( + raw_data=raw_data, + number_of_sampling_for_centroids=number_of_sampling_for_centroids, + coreset_size=coreset_size, + number_of_coresets_to_evaluate=number_of_coresets_to_evaluate, + coreset_method=coreset_method, + ) + + coreset_vectors, coreset_weights = coreset.get_best_coresets() + + coreset_df = pd.DataFrame({ + "X": coreset_vectors[:, 0], + "Y": coreset_vectors[:, 1], + "weights": coreset_weights, + }) + coreset_df["Name"] = [chr(i + 65) for i in coreset_df.index] + + return coreset_df + + +if __name__ == "__main__": + cudaq.set_target(target) + + coreset_df = create_coreset_df( + raw_data_size=1000, + number_of_sampling_for_centroids=10, + coreset_size=coreset_size, + number_of_coresets_to_evaluate=4, + coreset_method="BFL2", + ) + + optimizer = cudaq.optimizers.COBYLA() + + divisive_clustering = DivisiveClusteringVQA( + circuit_depth=circuit_depth, + max_iterations=max_iterations, + max_shots=max_shots, + threshold_for_max_cut=0.5, + create_Hamiltonian=get_K2_Hamiltonian, + optimizer=optimizer, + optimizer_function=get_optimizer, + create_circuit=get_QAOA_circuit, + normalize_vectors=True, + sort_by_descending=True, + coreset_to_graph_metric="dist", + ) + + t0 = time.process_time() + + hierarchial_clustering_sequence = divisive_clustering.get_divisive_sequence( + coreset_df) + tf = time.process_time() + + print(f"Total time for the execution: {tf - t0}") + + print(f"Total time spent on CUDA-Q: {divisive_clustering.time_consumed}") diff --git a/pr-2023/sphinx/examples/python/tutorials/images/circuit_pdf.png b/pr-2023/sphinx/examples/python/tutorials/images/circuit_pdf.png new file mode 100644 index 0000000000..b5c85f495d Binary files /dev/null and b/pr-2023/sphinx/examples/python/tutorials/images/circuit_pdf.png differ diff --git a/pr-2023/sphinx/examples/python/tutorials/readout_error_mitigation.ipynb b/pr-2023/sphinx/examples/python/tutorials/readout_error_mitigation.ipynb index cec9dea413..1d1fee4095 100644 --- a/pr-2023/sphinx/examples/python/tutorials/readout_error_mitigation.ipynb +++ b/pr-2023/sphinx/examples/python/tutorials/readout_error_mitigation.ipynb @@ -7,7 +7,7 @@ "source": [ "# Readout Error Mitigation\n", "\n", - "Readout errors are caused by imperfect qubit measurement and are a common source of error in quantum computing. Properly modelling these errors in simulation can give the user tools to understand better how these errors are and how to mitigate them when running on actual quantum devices.\n", + "Readout errors are caused by imperfect qubit measurement and are a common source of error in quantum computing. Properly modelling these errors in simulation can give the user tools to understand better what these errors are and how to mitigate them when running on actual quantum devices.\n", "\n", "Readout errors can be mitigated with a confusion matrix $A$. It is a square matrix of size $2^n \\times 2^n$ and tells about the probability of observing the state $|y\\rangle$ given the true state $|x\\rangle$. The confusion matrix characterizes the readout error of the device and is circuit-independent. Once $A$ is estimated, we can compute its pseudoinverse $A^+$ which can be applied to the noisy probability distribution $p_{\\text{noisy}}$ to obtain an adjusted quasi-probability distribution \n", "\n", @@ -18,7 +18,7 @@ "In this tutorial, we show how to build a confusion matrix with the following approaches.\n", "\n", "- Using a single qubit model\n", - "- using $k$ local confusion matrices\n", + "- Using $k$ local confusion matrices\n", "- A full confusion matrix for each $2^n$ combination\n", "\n", "The last method works well for correcting correlated errors (which affect multiple qubits together). However, it becomes impractical for large numbers of qubits." @@ -73,7 +73,7 @@ "To model the readout error, we apply a bitflip channel on every qubit at the end of the circuit using an Identity gate. The probability of bitflip `probs` can be the same or different for all the qubits.\n", "\n", "
    Note: \n", - "In principle, readout error is applied to the measurement gate but we use Identity gate as adding a quantum error on the measurement gate is not yet supported. Also, the Identity gate is not present in the add_channel method, so we model the Identity gate using a rotation gate with an angle of 0.0.\n", + "In principle, readout error is applied to the measurement gate but we use the Identity gate because adding a quantum error on the measurement gate is not yet supported. Also, the Identity gate is not present in the add_channel method, so we model the Identity gate using a rotation gate with an angle of 0.0.\n", "
    " ] }, @@ -114,7 +114,7 @@ "id": "bb4c7a14-1c0c-4fab-a6aa-7174c23baa7f", "metadata": {}, "source": [ - "We define a cudaq kernel which will help create a set of quantum circuits to take measurements of the basis states for $n$ qubits. It takes the number of qubits and the basis state as arguments." + "We define a cudaq kernel which will help create a set of quantum circuits to take measurements of the basis states for $n$ qubits. The kernel takes the number of qubits and the basis state as arguments." ] }, { @@ -141,7 +141,7 @@ "id": "95411463-cd1e-499f-baef-d624acc0122c", "metadata": {}, "source": [ - "For the tutorial, we will use GHZ state on three qubits for testing readout error mitigation. The GHZ state on 3 qubits is described as:\n", + "For the tutorial, we will use the GHZ state on three qubits to test readout error mitigation. The GHZ state on 3 qubits is described as:\n", "\n", "$$\n", "\\frac{|000\\rangle + |111\\rangle}{\\sqrt{2}}\n", @@ -163,7 +163,7 @@ " for i in range(n_qubits - 1):\n", " cx(qvector[i], qvector[i + 1])\n", "\n", - " # Apply id gates for readout error mitigation\n", + " # Apply identity gates for readout error mitigation\n", " for i in range(n_qubits):\n", " rx(0.0, qvector[i])\n", "\n", @@ -199,7 +199,7 @@ "id": "032f6898-c953-4d30-a2bf-e8b46ee77c62", "metadata": {}, "source": [ - "It is possible that the adjusted quasi-probability distribution $p_{\\text{mitigated}}$ obtained by application of $A^+$ to $p_{\\text{noisy}}$ can be possibly non-positive. We need to find the closest positive probability distribution in such a case.\n", + "It is possible that the adjusted quasi-probability distribution $p_{\\text{mitigated}}$ obtained by application of $A^+$ to $p_{\\text{noisy}}$ may be non-positive. We need to find the closest positive probability distribution in such a case.\n", "\n", " $$ p'' = \\min_{p_{\\rm positive}} \\|p_{\\rm noisy} - p_{\\rm positive}\\|_1$$\n", "\n", @@ -393,7 +393,7 @@ "source": [ "## Inverse confusion matrix from single-qubit noise model\n", "\n", - "Here we assume that the readout error of each qubit is independent and with the same confusion probabilities. Then, the confusion matrix $A_1$ for a single qubit can be defined as\n", + "Here we assume that the readout error of each qubit is independent with the same confusion probabilities. Then, the confusion matrix $A_1$ for a single qubit can be defined as\n", "\n", "$$\n", "A_1 = \\begin{bmatrix}\n", @@ -402,7 +402,7 @@ "\\end{bmatrix}\n", "$$\n", "\n", - "where $P(y|x)$ is the probability of observing state $|y\\rangle$ when measuring true state $|x\\rangle$. Using $A_1$ the full $2^n \\times 2^n$ confusion matrix $A$ can be written as \n", + "where $P(y|x)$ is the probability of observing state $|y\\rangle$ when measuring the true state $|x\\rangle$. Using $A_1$, the full $2^n \\times 2^n$ confusion matrix $A$ can be written as \n", "\n", "$$\n", "A = A_1 \\otimes \\dots \\otimes A_1\n", @@ -719,7 +719,7 @@ "source": [ "## Inverse of full confusion matrix\n", "\n", - "Here we generate a quantum circuit for each of the basis states of $n$ qubits i.e. $2^n$ combinations. This gives more accurate readout error mitigation. Since it scales exponentially with the number of qubits, it is only practical for small devices." + "Here we generate a quantum circuit for each of the basis states of $n$ qubits (i.e., $2^n$ combinations). This gives more accurate readout error mitigation. Since it scales exponentially with the number of qubits, it is only practical for small devices." ] }, { diff --git a/pr-2023/sphinx/examples/python/tutorials/visualization.ipynb b/pr-2023/sphinx/examples/python/tutorials/visualization.ipynb new file mode 100644 index 0000000000..0915f4809d --- /dev/null +++ b/pr-2023/sphinx/examples/python/tutorials/visualization.ipynb @@ -0,0 +1,299 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualization\n", + "\n", + "## Qubit Visualization\n", + "\n", + "What are the possible states a qubit can be in and how can we build up a visual cue to help us make sense of quantum states and their evolution?\n", + "\n", + "We know our qubit can have two distinct states: $\\ket{0}$ and $\\ket{1}$. Maybe we need a one-dimensional line whose vertices can\n", + "represent each of the states. We also know that qubits can be in an equal superposition states: $\\ket{+}$ and $\\ket{-}$. This now forces us to extend our 1D line to a 2D Cartesian coordinate system. If you dive deeper you will learn about the existence of states like \n", + "$\\ket{+i}$ and $\\ket{-i}$, this calls for a 3D extension.\n", + "\n", + "It turns out that a sphere is able to depict all the possible states of a single qubit. This is called a Bloch sphere. \n", + "\n", + "\"Bloch\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us try to showcase the functionality to render such a 3D representation with CUDA-Q. \n", + "First, let us define a single-qubit kernel that returns a different state each time. This kernel uses random rotations.\n", + "\n", + "Note: CUDA-Q uses the [QuTiP](https://qutip.org) library to render Bloch spheres. The following code will throw an error if QuTiP is not installed. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# install `qutip` in the current Python kernel. Skip this if `qutip` is already installed.\n", + "# `matplotlib` is required for all visualization tasks.\n", + "# Make sure to restart your kernel if you execute this!\n", + "# In a Jupyter notebook, go to the menu bar > Kernel > Restart Kernel.\n", + "# In VSCode, click on the Restart button in the Jupyter toolbar.\n", + "\n", + "# The '\\' before the '>' operator is so that the shell does not misunderstand\n", + "# the '>' qualifier for the bash pipe operation.\n", + "\n", + "import sys\n", + "\n", + "try:\n", + " import matplotlib.pyplot as plt\n", + " import qutip\n", + "\n", + "except ImportError:\n", + " print(\"Tools not found, installing. Please restart your kernel after this is done.\")\n", + " !{sys.executable} -m pip install qutip\\>=5 matplotlib\\>=3.5\n", + " print(\"\\nNew libraries have been installed. Please restart your kernel!\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import cudaq\n", + "import numpy as np\n", + "\n", + "## Retry the subsequent cells by setting the target to density matrix simulator.\n", + "# cudaq.set_target(\"density-matrix-cpu\")\n", + "\n", + "\n", + "@cudaq.kernel\n", + "def kernel(angles: np.ndarray):\n", + " qubit = cudaq.qubit()\n", + " rz(angles[0], qubit)\n", + " rx(angles[1], qubit)\n", + " rz(angles[2], qubit)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we instantiate a random number generator, so we can get random outputs. We then create 4 random single-qubit states by using `cudaq.add_to_bloch_sphere()` on the output state obtained from the random kernel." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "rng = np.random.default_rng(seed=11)\n", + "blochSphereList = []\n", + "for _ in range(4):\n", + " angleList = rng.random(3) * 2 * np.pi\n", + " sph = cudaq.add_to_bloch_sphere(cudaq.get_state(kernel, angleList))\n", + " blochSphereList.append(sph)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can display the spheres with `cudaq.show()`. Show the first sphere:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cudaq.show(blochSphereList[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also show multiple Bloch spheres side by side - simply set the `nrows` and `ncols` in the call to `cudaq.show()` accordingly. Make sure to have more spaces than spheres in your list, else it will throw an error! Let us show two spheres in a row:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cudaq.show(blochSphereList[:2], nrows=1, ncols=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can show them in a column too, if we want! Simply set the `nrows = 2` and `ncols = 1`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cudaq.show(blochSphereList[:2], nrows=2, ncols=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Can we show the entire list of 4 Bloch spheres we created? Absolutely!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cudaq.show(blochSphereList[:], nrows=2, ncols=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What if we had to add multiple vectors to a single Bloch sphere? CUDA-Q uses the [QuTiP](https://www.qutip.org) toolbox to construct Bloch spheres. We can then add multiple states to the same Bloch sphere by passing the sphere object as an argument to `cudaq.add_to_bloch_sphere()`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import qutip\n", + "\n", + "rng = np.random.default_rng(seed=47)\n", + "blochSphere = qutip.Bloch()\n", + "for _ in range(10):\n", + " angleList = rng.random(3) * 2 * np.pi\n", + " sph = cudaq.add_to_bloch_sphere(cudaq.get_state(kernel, angleList), blochSphere)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This created a single Bloch sphere with 10 random vectors. Let us see how it looks." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "blochSphere.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Unfortunately, there is no such handy visualization for multi-qubit states. In particular, a multi-qubit state cannot be visualized as multiple Bloch spheres due to the nature of entanglement that makes quantum computing so powerful. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Kernel Visualization\n", + "\n", + "A CUDA-Q kernel can be visualized using the `cudaq.draw` API which returns a string representing the drawing of the execution path, in the specified format. ASCII (default) and LaTeX formats are supported." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "@cudaq.kernel\n", + "def kernel_to_draw():\n", + " q = cudaq.qvector(4)\n", + " h(q)\n", + " x.ctrl(q[0], q[1])\n", + " y.ctrl([q[0], q[1]], q[2])\n", + " z(q[2])\n", + " \n", + " swap(q[0], q[1])\n", + " swap(q[0], q[3])\n", + " swap(q[1], q[2])\n", + "\n", + " r1(3.14159, q[0])\n", + " tdg(q[1])\n", + " s(q[2])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(cudaq.draw(kernel_to_draw))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(cudaq.draw('latex', kernel_to_draw))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Copy this output string into any LaTeX editor and export it to PDF.\n", + "\n", + "\"Circuit" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "vscode": { + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/pr-2023/sphinx/releases.rst b/pr-2023/sphinx/releases.rst index e9ac3adfad..6a8a353462 100644 --- a/pr-2023/sphinx/releases.rst +++ b/pr-2023/sphinx/releases.rst @@ -10,6 +10,37 @@ The latest version of CUDA-Q is on the main branch of our `GitHub repository `__ - `Examples `__ +**0.8.0** + +The 0.8.0 release adds a range of changes to improve the ease of use and performance with CUDA-Q. +The changes listed below highlight some of what we think will be the most useful features and changes +to know about. While the listed changes do not capture all of the great contributions, we would like +to extend many thanks for every contribution, in particular those from external contributors. + +- `Docker image `__ +- `Python wheel `__ +- `C++ installer `__ +- `Documentation `__ +- `Examples `__ + +The full change log can be found `here `__. + +**0.7.1** + +The 0.7.1 release adds simulator optimizations with significant performance improvements and +extends their functionalities. The `nvidia-mgpu` backend now supports user customization of the +gate fusion level as controlled by the `CUDAQ_MGPU_FUSE` environment variable documented +`here `__. +It furthermore adds a range of bug fixes and changes the Python wheel installation instructions. + +- `Docker image `__ +- `Python wheel `__ +- `C++ installer `__ +- `Documentation `__ +- `Examples `__ + +The full change log can be found `here `__. + **0.7.0** The 0.7.0 release adds support for using :doc:`NVIDIA Quantum Cloud `, @@ -19,13 +50,13 @@ Check out our `documentation `__ to learn more about the new setup and its performance benefits. -- `Docker image `__ -- `Python wheel `__ -- `C++ installer `__ +- `Docker image `__ +- `Python wheel `__ +- `C++ installer `__ - `Documentation `__ - `Examples `__ -The full change log can be found `here `__. +The full change log can be found `here `__. **0.6.0** diff --git a/pr-2023/sphinx/snippets/cpp/using/cudaq/platform/sample_async_remote.cpp b/pr-2023/sphinx/snippets/cpp/using/cudaq/platform/sample_async_remote.cpp index ac42dcc315..18371c8677 100644 --- a/pr-2023/sphinx/snippets/cpp/using/cudaq/platform/sample_async_remote.cpp +++ b/pr-2023/sphinx/snippets/cpp/using/cudaq/platform/sample_async_remote.cpp @@ -8,9 +8,9 @@ // Compile and run with: // ``` -// nvq++ sample_async.cpp -o sample_async.x --target remote-mqpu -// --remote-mqpu-auto-launch 2 -// && ./sample_async.x +// nvq++ sample_async_remote.cpp -o sample.x \ +// --target remote-mqpu --remote-mqpu-auto-launch 2 +// ./sample.x // ``` #include diff --git a/pr-2023/sphinx/snippets/cpp/using/two_qubit_custom_op.cpp b/pr-2023/sphinx/snippets/cpp/using/two_qubit_custom_op.cpp new file mode 100644 index 0000000000..a11644bdaa --- /dev/null +++ b/pr-2023/sphinx/snippets/cpp/using/two_qubit_custom_op.cpp @@ -0,0 +1,38 @@ +/******************************************************************************* + * Copyright (c) 2022 - 2024 NVIDIA Corporation & Affiliates. * + * All rights reserved. * + * * + * This source code and the accompanying materials are made available under * + * the terms of the Apache License 2.0 which accompanies this distribution. * + ******************************************************************************/ + +// [Begin Docs] +#include + +CUDAQ_REGISTER_OPERATION(MyCNOT, 2, 0, + {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0}); + +CUDAQ_REGISTER_OPERATION( + MyXY, 2, 0, + {0, 0, 0, {0, -1}, 0, 0, {0, 1}, 0, 0, {0, -1}, 0, 0, {0, 1}, 0, 0, 0}); + +__qpu__ void bell_pair() { + cudaq::qubit q, r; + h(q); + MyCNOT(q, r); // MyCNOT(control, target) +} + +__qpu__ void custom_xy_test() { + cudaq::qubit q, r; + MyXY(q, r); + y(r); // undo the prior Y gate on qubit 1 +} + +int main() { + auto counts = cudaq::sample(bell_pair); + counts.dump(); // prints { 11:500 00:500 } (exact numbers will be random) + + counts = cudaq::sample(custom_xy_test); + counts.dump(); // prints { 10:1000 } +} +// [End Docs] diff --git a/pr-2023/sphinx/snippets/python/using/examples/two_qubit_custom_op.py b/pr-2023/sphinx/snippets/python/using/examples/two_qubit_custom_op.py new file mode 100644 index 0000000000..d42feb6e34 --- /dev/null +++ b/pr-2023/sphinx/snippets/python/using/examples/two_qubit_custom_op.py @@ -0,0 +1,48 @@ +# ============================================================================ # +# Copyright (c) 2022 - 2024 NVIDIA Corporation & Affiliates. # +# All rights reserved. # +# # +# This source code and the accompanying materials are made available under # +# the terms of the Apache License 2.0 which accompanies this distribution. # +# ============================================================================ # + +# fmt: off +#[Begin Docs] +import cudaq +import numpy as np + +# Create and test a custom CNOT operation. +cudaq.register_operation("my_cnot", np.array([1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 0, 1, + 0, 0, 1, 0])) + +@cudaq.kernel +def bell_pair(): + qubits = cudaq.qvector(2) + h(qubits[0]) + my_cnot(qubits[0], qubits[1]) # `my_cnot(control, target)` + + +cudaq.sample(bell_pair).dump() # prints { 11:500 00:500 } (exact numbers will be random) + + +# Construct a custom unitary matrix for X on the first qubit and Y +# on the second qubit. +X = np.array([[0, 1 ], [1 , 0]]) +Y = np.array([[0, -1j], [1j, 0]]) +XY = np.kron(X, Y) + +# Register the custom operation +cudaq.register_operation("my_XY", XY) + +@cudaq.kernel +def custom_xy_test(): + qubits = cudaq.qvector(2) + my_XY(qubits[0], qubits[1]) + y(qubits[1]) # undo the prior Y gate on qubit 1 + + +cudaq.sample(custom_xy_test).dump() # prints { 10:1000 } +#[End Docs] +# fmt: on diff --git a/pr-2023/sphinx/using/backends/platform.rst b/pr-2023/sphinx/using/backends/platform.rst index e2d3604300..18753617c9 100644 --- a/pr-2023/sphinx/using/backends/platform.rst +++ b/pr-2023/sphinx/using/backends/platform.rst @@ -49,7 +49,8 @@ Here is a simple example demonstrating its usage. ./a.out CUDA-Q exposes asynchronous versions of the default :code:`cudaq` algorithmic -primitive functions like :code:`sample` and :code:`observe` (e.g., :code:`sample_async` function in the above code snippets). +primitive functions like :code:`sample`, :code:`observe`, and :code:`get_state` +(e.g., :code:`sample_async` function in the above code snippets). Depending on the number of GPUs available on the system, the :code:`nvidia` multi-QPU platform will create the same number of virtual QPU instances. For example, on a system with 4 GPUs, the above code will distribute the four sampling tasks among those :code:`GPUEmulatedQPU` instances. @@ -70,6 +71,30 @@ The results might look like the following 4 different random samplings: To specify the number QPUs to be instantiated, one can set the :code:`CUDAQ_MQPU_NGPUS` environment variable. For example, use :code:`export CUDAQ_MQPU_NGPUS=2` to specify that only 2 QPUs (GPUs) are needed. +Since the underlying :code:`GPUEmulatedQPU` is a simulator backend, we can also retrieve the state vector from each +QPU via the :code:`cudaq::get_state_async` (C++) or :code:`cudaq.get_state_async` (Python) as shown in the bellow code snippets. + +.. tab:: Python + + .. literalinclude:: ../../snippets/python/using/cudaq/platform/get_state_async.py + :language: python + :start-after: [Begin Documentation] + +.. tab:: C++ + + .. literalinclude:: ../../snippets/cpp/using/cudaq/platform/get_state_async.cpp + :language: cpp + :start-after: [Begin Documentation] + :end-before: [End Documentation] + + + One can specify the target multi-QPU architecture with the :code:`--target` flag: + + .. code-block:: console + + nvq++ get_state_async.cpp --target nvidia --target-option mqpu + ./a.out + .. deprecated:: 0.8 The :code:`nvidia-mqpu` and :code:`nvidia-mqpu-fp64` targets, which are equivalent to the multi-QPU options `mgpu,fp32` and `mgpu,fp64`, respectively, of the :code:`nvidia` target, are deprecated and will be removed in a future release. @@ -270,3 +295,47 @@ language constructs within quantum kernels may not yet be fully supported. For CUDA-Q kernels that return a value, the remote platform supports returning simple data types of `bool`, integral (e.g., `int` or `std::size_t`), and floating-point types (`float` or `double`) when MLIR-based compilation is enabled (:code:`--enable-mlir`). + +Accessing Simulated Quantum State +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The remote `MQPU` platform supports accessing simulator backend's state vector via the +`cudaq::get_state` (C++) or `cudaq.get_state` (Python) APIs, similar to local simulator backends. + +State data can be retrieved as a full state vector or as individual basis states' amplitudes. +The later is designed for large quantum states, which incurred data transfer overheads. + +.. tab:: Python + + .. code:: python + + state = cudaq.get_state(kernel) + amplitudes = state.amplitudes(['0000', '1111']) + +.. tab:: C++ + + .. code-block:: cpp + + auto state = cudaq::get_state(kernel) + auto amplitudes = state.amplitudes({{0, 0, 0, 0}, {1, 1, 1, 1}}); + +In the above example, the amplitudes of the two requested states are returned. + +For C++ quantum kernels [*]_ compiled with the CUDA-Q MLIR-based compiler and Python kernels, +state accessor is evaluated in a just-in-time/on-demand manner, and hence can be customize to +users' need. + +For instance, in the above amplitude access example, if the state vector is very large, e.g., +multi-GPU distributed state vectors or tensor-network encoded quantum states, the full state vector +will not be retrieved when `get_state` is called. Instead, when the `amplitudes` accessor is called, +a specific amplitude calculation request will be sent to the server. +Thus, only the amplitudes of those basis states will be computed and returned. + +Similarly, for state overlap calculation, if deferred state evaluation is available (Python/MLIR-based compiler) +for both of the operand quantum states, a custom overlap calculation request will be constructed and sent to the server. +Only the final overlap result will be returned, thereby eliminating back-and-forth state data transfers. + +.. [*] Only C++ quantum kernels whose names are available via run-time type information (RTTI) are supported. + For example, quantum kernels expressed as named `struct` are supported but not standalone functions. + Kernels that do not have deferred state evaluation support will perform synchronous `get_state`, whereby the full state + vector is returned from the server immediately. diff --git a/pr-2023/sphinx/using/examples/examples.rst b/pr-2023/sphinx/using/examples/examples.rst index 2ae41ca6fa..2c35b360a3 100644 --- a/pr-2023/sphinx/using/examples/examples.rst +++ b/pr-2023/sphinx/using/examples/examples.rst @@ -9,6 +9,7 @@ Examples that illustrate how to use CUDA-Q for application development are avail Introduction Quantum Operations + Visualization <../../examples/python/tutorials/visualization.ipynb> Computing Expectation Values Multi-Control Synthesis Multi-GPU Workflows diff --git a/pr-2023/sphinx/using/examples/quantum_operations.rst b/pr-2023/sphinx/using/examples/quantum_operations.rst index 28c186af42..5e70e9b4f1 100644 --- a/pr-2023/sphinx/using/examples/quantum_operations.rst +++ b/pr-2023/sphinx/using/examples/quantum_operations.rst @@ -173,30 +173,3 @@ where the probability of measuring :math:`x = 00, 01, 10, 11` occurs with probability :math:`\lvert \alpha_{x} \rvert ^2` with the normalization condition that :math:`\sum_{x \in \{ 0,1 \}^2} \lvert \alpha_{x} \rvert ^2 = 1`. - - -State Visualization ------------------------------ - -What are the possible states a qubit can be in and how can we build up -a visual cue to help us make sense of quantum states and their -evolution? - -We know our qubit can have two distinct states: :math:`\ket{0}` and -:math:`\ket{1}`. Maybe we need a one-dimensional line whose vertices can -represent each of the aforementioned states. -We also know that qubits can be in an equal superposition states: -:math:`\ket{+}` and :math:`\ket{-}`. This now forces us to extend our -1D line to a 2D Cartesian coordinate system. -If you dive deeper you will learn about the existence of states like -:math:`\ket{+i}` and :math:`\ket{-i}`, this calls for a 3D -extension. - -It turns out that a sphere is able to depict all the possible states of -a single qubit. This is called a Bloch sphere. - -Unfortunately, there is no such handy visualization for multi-qubit states. -In particular, a multi-qubit state cannot be visualized as multiple Bloch -spheres due to the nature of entanglement that makes quantum computing so powerful. - - diff --git a/pr-2023/sphinx/using/install/data_center_install.rst b/pr-2023/sphinx/using/install/data_center_install.rst index 0100e352b3..f65d1ac7bf 100644 --- a/pr-2023/sphinx/using/install/data_center_install.rst +++ b/pr-2023/sphinx/using/install/data_center_install.rst @@ -14,13 +14,16 @@ on how to do that. Our installation guide also contains instructions for how to :ref:`connect an IDE ` to a running container. If you do not want use a container runtime, we also provide pre-built binaries -for using CUDA-Q with C++. These binaries are built following the instructions +for using CUDA-Q with C++, and Python wheels for using CUDA-Q with Python. +These binaries and wheels are built following the instructions in this guide and should work for you as long as your system meets the compatibility requirements listed under :ref:`Prerequisites `. -To install them, please follow the instructions :ref:`here `. +To install the pre-built binaries, please follow the instructions +:ref:`here `. To install the Python wheels, please +follow the instructions :ref:`here `. -If our pre-built packages are not a good option for you, e.g. because you would -like to use CUDA-Q on an operating system that is not officially supported, +If your system is not listed as supported by our official packages, e.g. because you would +like to use CUDA-Q on an operating system that uses an older C standard library, please follow this guide carefully without skipping any steps to build and install CUDA-Q from source. The rest of this guide details system requirements during the build and after installation, and walks through the installation steps. @@ -145,10 +148,12 @@ CUDA ~~~~~~~~~~ Building CUDA-Q requires a full installation of the CUDA toolkit. +**You can install the CUDA toolkit and use the CUDA compiler without having a GPU.** The instructions are tested using version 11.8, but any CUDA 11 or 12 version -should work, as long as the installed driver on the host +should work, as long as the CUDA runtime version on the host system matches the +CUDA version used for the build, and the installed driver on the host system supports that CUDA version. We recommend using the latest CUDA version -that is supported by your driver. +that is supported by the driver on the host system. Download a suitable `CUDA version `__ following the installation guide for your platform in the online documentation @@ -166,13 +171,10 @@ install CUDA 11.8: Toolchain ~~~~~~~~~~ -The compiler toolchain used for the build needs to support C++20 and must be a supported +The compiler toolchain used for the build must be a supported `CUDA host compiler `__ for the installed CUDA version. -The following instructions have been tested with -`GCC-11 `__ as your toolchain for building CUDA-Q. -If you use a different compiler, we recommend using an OpenMP-enabled compiler. At this -time, we actively test building with GCC 11 and 12, as well as with Clang 16. +The following instructions have been tested with `GCC-11 `__. Other toolchains may be supported but have not been tested. Within the tested AlmaLinux 8 environment, for example, the following commands @@ -194,12 +196,9 @@ environment variables to point to the respective compilers on your build system: :end-before: [CUDAQuantumCppBuild] - :end-before: [`__. To do so, download the -`makeself script(s) `__ and move the necessary -files to install into a separate folder using the command - -.. literalinclude:: ../../../../docker/release/installer.Dockerfile - :language: bash - :dedent: - :start-after: [>CUDAQuantumAssets] - :end-before: [`__ that can then easily be installed using `pip`. To ensure the wheel can be installed on the host system, make sure to use the same Python version for the build as the one that is installed on the host system. -To build the CUDA-Q Python wheel, you will need to install the following additional +To build a CUDA-Q Python wheel, you will need to install the following additional Python-specific tools: - Python development headers: The development headers for your Python version are installed @@ -327,19 +289,59 @@ installed on any `compatible platform CUDAQuantumCppBuild] + :end-before: [`__. To do so, download the +`makeself script(s) `__ and move the necessary +files to install into a separate folder using the command + +.. literalinclude:: ../../../../docker/release/installer.Dockerfile + :language: bash + :dedent: + :start-after: [>CUDAQuantumAssets] + :end-before: [`__ - is installed and discoverable on your host system. - CUDA-Q supports the GNU C++ standard library (`libstdc++`), - version 11 or newer. Other libraries may work but can cause issues in certain cases. - To use CUDA-Q with Python, you should have a working Python installation on the host system, including the `pip` package manager. +- To use CUDA-Q with C++, you should make sure that you have the necessary development + headers of the C standard library installed. You can check this by searching for + `features.h`, commonly found in `/usr/include/`. You can install the necessary headers + via package manager (usually the package name is called something like `glibc-devel` + or `libc6-devel`). These headers are also included with any installation of GCC. + +To use CUDA-Q with Python, you should have a working +Python installation on the host system, including the `pip` package manager. If you followed the instructions for building the :ref:`CUDA-Q Python wheel `, @@ -377,21 +379,25 @@ the `/etc/profile` file: . /opt/nvidia/cudaq/set_env.sh fi -.. note:: - - CUDA-Q includes its own linker, specifically the `LLD `__ - linker. You can customize which linker the `nvq++` compiler uses by setting the - `NVQPP_LD_PATH` environment variable; for example `export NVQPP_LD_PATH=ld`. +.. note:: + CUDA-Q as built following the instructions above includes and uses the LLVM + C++ standard library. This will not interfere with any other C++ standard library + you may have on your system. Pre-built external libraries, you may want to use with + CUDA-Q, such as specific optimizers for example, have a C API to ensure compatibility + across different versions of the C++ standard library and will work with CUDA-Q without + issues. The same is true for all distributed CUDA libraries. To build you own CUDA + libraries that can be used with CUDA-Q, please take a look at :doc:`../integration/cuda_gpu`. The remaining sections in this document list additional runtime dependencies that are not included in the migrated assets and are needed to use some of the CUDA-Q features and components. CUDA Runtime Libraries -~~~~~~~~~~~~~~~~~~~~~~~ +~~~~~~~~~~~~~~~~~~~~~~~~~~~ To use GPU-acceleration in CUDA-Q you will need to install the necessary -CUDA runtime libraries. While not necessary, we recommend installing +CUDA runtime libraries. Their version (at least the version major) needs to match the version +used for the build. While not necessary, we recommend installing the complete CUDA toolkit like you did for the CUDA-Q build. If you prefer to only install the minimal set of runtime libraries, the following commands, for example, install the necessary packages for the AlmaLinux 8 environment: diff --git a/pr-2023/sphinx/using/install/local_installation.rst b/pr-2023/sphinx/using/install/local_installation.rst index e4696f02a4..695dc6de72 100644 --- a/pr-2023/sphinx/using/install/local_installation.rst +++ b/pr-2023/sphinx/using/install/local_installation.rst @@ -251,13 +251,15 @@ To install CUDA-Q, execute the command .. note:: - To use GPU-accelerated backends, you will need to install the necessary CUDA runtime libraries. For more information see the corresponding section on :ref:`Additional CUDA Tools `. + To use GPU-accelerated backends, you will need to install the necessary CUDA runtime libraries. + For more information see the corresponding section on + :ref:`Additional CUDA Tools `. The installation ensures that the necessary environment variables for using the CUDA-Q toolchain are set upon login for all POSIX shells. Confirm that the `nvq++` command is found. If it is not, please make sure to set the environment variables defined by the `set_env.sh` script in the -CUDA-Q installation folder (usually `/opt/nvidia/cudaq`). +CUDA-Q installation folder (usually `/usr/local/cudaq` or `/opt/nvidia/cudaq`). If an MPI installation is available in the directory defined by `MPI_PATH`, the installer automatically enables MPI support in CUDA-Q. @@ -272,18 +274,15 @@ executing the commands MPI_PATH=/usr/local/openmpi # update this path as needed bash "${CUDA_QUANTUM_PATH}/distributed_interfaces/activate_custom_mpi.sh" -.. _local-development-with-vscode: +.. note:: -To develop C++ code, you most likely also want to install the -`C++ standard library `__. -CUDA-Q supports the GNU C++ standard library (`libstdc++`), -version 11 or newer. Other libraries may work but can cause issues in certain cases. -The C++ standard library, including development headers, is almost certainly -available via the package manager for your system. To ensure the libraries and headers -are discoverable, the easiest option is usually to install the complete GCC toolchain. -Note that for certain distributions, you may need to manually enable that version -after installation by running a script called `enable`. You can search for such a -script with the command `find / -path '*gcc*' -name enable`. + Please make sure that you have the necessary development headers of the C standard + library installed. You can check this by searching for `features.h`, commonly found + in `/usr/include/`. You can install the necessary headers via package manager + (usually the package name is called something like `glibc-devel` or `libc6-dev`). + These headers are also included with any installation of GCC. + +.. _local-development-with-vscode: Development with VS Code ------------------------------------ @@ -687,7 +686,7 @@ Installing Pre-built Binaries ++++++++++++++++++++++++++++++++++++ If you installed pre-built binaries for CUDA-Q, you will need to install -the necessary CUDA runtime libraries to use GPU-acceleration in CUDA-Q. +the necessary CUDA 11 runtime libraries to use GPU-acceleration in CUDA-Q. If you prefer to only install the minimal set of runtime libraries, the following commands, for example, install the necessary packages for RHEL 8: @@ -698,8 +697,8 @@ commands, for example, install the necessary packages for RHEL 8: :end-before: [`__. -Please make sure to install CUDA version 11.8 or newer, and confirm that your +linked for that `CUDA version `__. +Please make sure to install CUDA version 11.8, and confirm that your `GPU driver `__ supports that version. While the above packages are sufficient to use GPU-acceleration within CUDA-Q, we recommend installing the complete CUDA toolkit (`cuda-toolkit-11-8`) that also diff --git a/pr-2023/sphinx/using/integration/cuda_gpu.rst b/pr-2023/sphinx/using/integration/cuda_gpu.rst index 0f64acac62..4ad7c09f89 100644 --- a/pr-2023/sphinx/using/integration/cuda_gpu.rst +++ b/pr-2023/sphinx/using/integration/cuda_gpu.rst @@ -7,39 +7,107 @@ both the CUDA Toolkit and CUDA-Q tools. More about programming GPUs in CUDA can be found in the `Quick Start Guide `__. -Once the :code:`nvcc` compiler is installed, it is possible to write +Once the `nvcc` compiler is installed, it is possible to write CUDA kernels and have them execute on the system GPU. See NVIDIA's `An Easy Introduction to CUDA C and C++ `__ for more information on getting started with CUDA. CUDA code uses a unique syntax and is, typically, saved in a file with -the extension :code:`.cu`. For our example, assume we have written our -CUDA code in the file :code:`my_proj.cu`. +the extension `.cu`. For our example, assume we have written our +CUDA code in the file `my_proj.cu`. CUDA-Q code is a library-based extension of C++ and uses standard conforming C++ syntax. Typically, a quantum kernel would be -saved in a file with the :code:`.cpp` extension. Again for our +saved in a file with the `.cpp` extension. Again for our example, let's assume that we've written quantum kernels and saved -them in the file :code:`my_proj_quantum.cpp`. +them in the file `my_proj_quantum.cpp`. -There is a bit of a wrinkle to be aware of before we compile these two -compilation units. Version 11 (and earlier) of CUDA :code:`nvcc` -supports the C++ 11, 14, and 17 standards and the default standard is -determined by the host C++ compiler. The CUDA-Q compiler, -:code:`nvq++`, defaults to the C++ 20 standard. To get around this -limitation, the project makefiles should select a common C++ standard -version. Fortunately, :code:`nvq++` does allow the use of C++ 17. +By default, CUDA-Q uses C++ 20 and builds source code against the +LLVM C++ standard library (`libc++`). To create a CUDA library that +can link against CUDA-Q code, make sure to define an API that does +not rely on C++ data structures that rely on a specific C++ toolchain +for all functions intended to be called from CUDA-Q (see also +:ref:`clike-shim`). For example, if you define a CUDA kernel in `my_proj.cu` -Note that starting with version 12 of the CUDA toolkit, the C++ 20 -standard is supported. +.. code-block:: cpp -Our project can then be built with commands such as + template + __global__ void cudaSetFirstNElements(CudaDataType *sv, const CudaDataType *__restrict__ sv2, int64_t N) { + int64_t i = static_cast(blockIdx.x) * blockDim.x + threadIdx.x; + if (i < N) { + sv[i].x = sv2[i].x; + sv[i].y = sv2[i].y; + } else { + sv[i].x = 0.0; + sv[i].y = 0.0; + } + } -.. code:: bash +define the following template and all desired template specializations - nvcc -c -std=c++17 my_proj.cu -o my_proj.o - nvq++ -std=c++17 my_project_quantum.cpp my_proj.o -L ${CUDA_INSTALL}/lib64 -lcudart -o my_executable +.. code-block:: cpp + + template + void setFirstNElements(uint32_t n_blocks, + int32_t threads_per_block, + void *newDeviceStateVector, + void *deviceStateVector, + std::size_t previousStateDimension) { + cudaSetFirstNElements<<>>( + reinterpret_cast(newDeviceStateVector), + reinterpret_cast(deviceStateVector), + previousStateDimension); + } + + template void + setFirstNElements(uint32_t n_blocks, + int32_t threads_per_block, + void *newDeviceStateVector, + void *deviceStateVector, + std::size_t previousStateDimension); + + template void + setFirstNElements(uint32_t n_blocks, + int32_t threads_per_block, + void *newDeviceStateVector, + void *deviceStateVector, + std::size_t previousStateDimension); + +Create the corresponding header file `my_proj.h` declaring the `setFirstNElements` +template. You can then call `setFirstNElements` from within `my_proj_quantum.cpp` +by including `my_proj.h`, for example + +.. code-block:: cpp + + #include "cuComplex.h" + #include "cuda_runtime.h" + #include "device_launch_parameters.h" + #include "my_proj.h" + + using namespace my_kernels; // the namespace where you defined setFirstNElements + + int main () { + const uint32_t n_blocks = 10; + const uint32_t threads_per_block = 5; + + void *deviceStateVector; + cudaMalloc((void **)&deviceStateVector, 2 * sizeof(cuDoubleComplex)); + // ... + void *newDeviceStateVector; + cudaMalloc((void **)&newDeviceStateVector, 2 * sizeof(cuDoubleComplex)); + setFirstNElements(n_blocks, threads_per_block, + newDeviceStateVector, deviceStateVector, + 2); + return 0; + } + +To get an executable, compile the code with + +.. code-block:: bash + + nvcc -c -std=c++17 -Xcompiler -fPIC my_proj.cu -o my_proj.o + nvq++ my_proj_quantum.cpp my_proj.o -I"${CUDA_HOME}/include/" -L"${CUDA_HOME}/lib64" -lcudart -o my_executable Above, :code:`nvq++` is used for the link step and will make sure the CUDA-Q runtime libraries are linked correctly to the executable program. diff --git a/pr-2023/sphinx/using/integration/integration.rst b/pr-2023/sphinx/using/integration/integration.rst index 1c2c26a113..ce6d6ab094 100644 --- a/pr-2023/sphinx/using/integration/integration.rst +++ b/pr-2023/sphinx/using/integration/integration.rst @@ -4,7 +4,8 @@ Integration with other Software Tools .. toctree:: :maxdepth: 1 - Combining CUDA with CUDA-Q Downstream CMake Integration + Combining CUDA with CUDA-Q + Integrating with Third-Party Libraries Information about customizing or extending the CUDA-Q toolchain can be found in :doc:`../extending/extending`. \ No newline at end of file diff --git a/pr-2023/sphinx/using/integration/libraries.rst b/pr-2023/sphinx/using/integration/libraries.rst new file mode 100644 index 0000000000..0e7c7c6fcd --- /dev/null +++ b/pr-2023/sphinx/using/integration/libraries.rst @@ -0,0 +1,226 @@ +Integrating with Third-Party Libraries +**************************************** + +CUDA-Q enables easily integrating quantum kernels with existing state-of-the-art tools +for classical computing and high performance computing. While quantum kernels are expressed +in Python or C++, quantum hardware backends only support a very limited set of classical +instructions. Correspondingly, only a select set of libraries and functions that are +directly supported by the CUDA-Q compiler can be called from within quantum kernels. +Code that is not marked as kernel code, on the other hand, can be used to invoke the +defined quantum kernels as well as any classical tools and libraries. CUDA-Q provides +a complete toolset to build complex applications running on multi-processor systems involving +CPUs, GPUs and QPUs. + +In Python, integration with any third-party Python package is handled +automatically without any need for additional configuration. For C++, the rest of this +document outlines how to integration with libraries that are compile with a different +compiler than `nvq++`. + + +Calling a CUDA-Q library from C++ +-------------------------------------- + +The CUDA-Q compiler is a fully-featured C++ compiler able to process arbitrary C++ code outside +of quantum kernels. In fact, the CUDA-Q installation includes and invokes a custom-built Clang +compiler under the hood. In general, it hence is not necessary to use a different compiler to +compile C++ host code that calls into quantum kernels; the host code is compiled along with +the quantum kernels into a single library or executable by the CUDA-Q toolchain. + +If you would still like to create a library that can be included in libraries and executables +built with a different toolchain, you can configure `nvq++` to include and encapsulate all its +C++ dependencies, such that the CUDA-Q library only depends on C libraries. For example, +if you have a file `quantum_kernel.cpp` containing + +.. code:: C++ + + #include "cudaq.h" + #include + #include + + namespace quantum { + + __qpu__ void bell() { + cudaq::qvector qs(2); + h(qs[0]); + cnot(qs[0], qs[1]); + mz(qs); + } + + // Usually, one would probably return something like + // the most probably value in the distribution rather + // than the string dump. However, the bell kernel here + // has a 50/50 chance of returning 00 or 11. + const char* bell_distribution() { + auto dist = cudaq::sample(bell); + + std::stringbuf buffer; + std::ostream os(&buffer); + dist.dump(os); + auto sample_results = buffer.str(); + + char* ptr = new char[sample_results.size() + 1]; + strcpy(ptr, sample_results.c_str()); + return ptr; + } + + } // namespace quantum + +you can create such a library with the command + +.. code:: bash + + nvq++ quantum_kernel.cpp -shared -static-libstdc++ -fPIC -o libquantum_kernel.so + +To use this library in a project built with an external toolchain, define a suitable +header file `quantum_kernel.h` containing + +.. code:: C++ + + namespace quantum { + const char* bell_distribution(); + } + +and include it in your project. For example, if `external.cpp` contains + +.. code:: C++ + + #include + #include "quantum_kernel.h" + + int main () { + // some code + auto bell_dist = quantum::bell_distribution(); + std::cout << bell_dist << std::endl; + delete[] bell_dist; + // more code + return 0; + } + +you can compile it with `g++` and link it with the built `libquantum_kernel.so` library +using the command + +.. code:: bash + + g++ external.cpp -lquantum_kernel -L"$(pwd)" -Wl,-rpath="$(pwd)" -I"$(pwd)" + +Note that the API defined in `quantum_kernel.h` does not depend on any data types that +rely on the specific implementation of the C++ standard library. For example, we return a +`const char*` instead of a `std::string` value. This is important to ensure that the data +is handled correctly regardless of which C++ standard library is used. If you include +data types that depend on a specific C++ ABI, the linker should detect this incompatibility +and should generate an error. See the section :ref:`clike-shim` below to learn more about +what to watch out for when defining an API to interface between libraries that are built +with different compilers. + + +Calling an C++ library from CUDA-Q +-------------------------------------- + +CUDA-Q comes with a complete C++ toolchain, and is configured to use its own C++ standard +library by default. When calling a third-party library from within a CUDA-Q application, +the quantum kernels and the surrounding application code are compiled with the `nvq++` compiler, +whereas the third-party library may be compiled with a different toolchain. +For most widely distributed libraries, this will work out of the box. The exception are +third-party libraries that are pre-compiled (opposed to being header-only libraries) +and dynamically depend on a different C++ standard library than CUDA-Q uses. +This is the case for a library `third_party_library.so` if `libstdc++.so` is listed +in the output of the command + +.. code:: bash + + ldd third_party_library.so + +To use such a library with CUDA-Q, you have to install the static version of the +library. The `nvq++` compiler can be configured to link a static library +`libexternal_library.a` instead of the shared one with the same flags as GCC/Clang: + +.. code:: bash + + nvq++ my_code.cpp -Wl,-Bstatic -lexternal_library -Wl,-Bdynamic ... + +If the compilation fails due to undefined symbols during linking, then `libexternal_library.a` +does not include the C++ standard library components it depends on. In this case, you can create a +suitable static library that contains the external library as well as its `libstdc++` dependencies +by combining `libexternal_library.a` and `libstdc++.a` into a single flattened archive. +For example, if the external library is built with GCC and located in `/usr/lib`, +the following commands create a suitable archive using the GNU archiver: + +.. code:: bash + + ar cruT libexternal_library_complete.a /usr/lib/libexternal_library.a "$(g++ -print-file-name=libstdc++.a)" + echo -e 'create libexternal_library_complete.a\naddlib libexternal_library_complete.a\nsave\nend' | ar -M + +The above commands create a new static library `libexternal_library_complete.a` in the current directory. +To use it, adjust the `nvq++` command accordingly: + +.. code:: bash + + nvq++ my_code.cpp -L. -Wl,-Bstatic -lexternal_library_complete -Wl,-Bdynamic ... + +.. note:: + + If the third-party library functions you are calling from your CUDA-Q code + consume or produce data types that explicitly depend on the C++ standard library implementation, + a small shim is needed to properly encapsulate these dependencies, as described in + :ref:`clike-shim`. + + +.. _clike-shim: + +Interfacing between binaries compiled with a different toolchains +--------------------------------------------------------------------- + +To avoid incompatibilities between different C++ implementations, +two binaries built using a different C++ compiler should be careful when passing data types between them +that rely on a specific C++ implementation. While primitive data types can be passed without +issues, attempting to pass a string, for example, will result in a linking failure; a `char*` must +be passed instead of a string. + +Most other data types, including templated types, can be passed as long as their alignment matches. +While different compilers generally align data differently, it is possible to force a particular +alignment when defining the data type or value. For example, if we define a struct + +.. code:: C++ + + #pragma pack(push, 4) + template + struct Entry { + bool is_integral; + ScalarType value; + }; + #pragma pack(pop) + +the `pragma` directives ensure that each item will be 4-byte aligned, regardless of the +default setting that can differ between compilers. + +Even function pointers can usually be passed, as long as their argument and return types can be passed. +When using templated functions and data types, the header file should only include their declaration as well +as explicit instantiation for all valid template arguments. For example, + +.. code:: C++ + + template + void initializeDeviceStateVector(uint32_t n_blocks, + int32_t threads_per_block, + void *deviceStateVector, + std::size_t stateDimension) { + cudaInitializeDeviceStateVector<<>>( + reinterpret_cast(deviceStateVector), stateDimension); + } + + template void + initializeDeviceStateVector(uint32_t n_blocks, + int32_t threads_per_block, + void *deviceStateVector, + std::size_t stateDimension); + + template void + initializeDeviceStateVector(uint32_t n_blocks, + int32_t threads_per_block, + void *deviceStateVector, + std::size_t stateDimension); + +The most cumbersome aspect when libraries built with different toolchains are combined into a single executable +is exception handling. Since the handling relies on a specific ABI, an thrown exception is not necessarily +recognized as such in a library that uses a different ABI implementation. While matching the exception type +may not work as expected, a catch-all will reliably catch any thrown exception. diff --git a/pr-2023/sphinx/using/tutorials.rst b/pr-2023/sphinx/using/tutorials.rst index a9fcfe3864..e1ded4b211 100644 --- a/pr-2023/sphinx/using/tutorials.rst +++ b/pr-2023/sphinx/using/tutorials.rst @@ -17,3 +17,4 @@ Tutorials that give an in depth view of CUDA-Q and its applications in Python. /examples/python/tutorials/noisy_simulations.ipynb /examples/python/tutorials/readout_error_mitigation.ipynb /examples/python/tutorials/vqe_water_active_space.ipynb + /examples/python/tutorials/Divisive_clustering.ipynb diff --git a/pr-2023/using/backends/backends.html b/pr-2023/using/backends/backends.html index 89cf26063a..b4da27aedb 100644 --- a/pr-2023/using/backends/backends.html +++ b/pr-2023/using/backends/backends.html @@ -30,7 +30,7 @@ - + @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • @@ -529,7 +549,7 @@ View page source
    @@ -578,7 +598,7 @@

    CUDA-Q Backends - +

    diff --git a/pr-2023/using/backends/hardware.html b/pr-2023/using/backends/hardware.html index f056ebf416..4a428652c1 100644 --- a/pr-2023/using/backends/hardware.html +++ b/pr-2023/using/backends/hardware.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/using/backends/nvqc.html b/pr-2023/using/backends/nvqc.html index b833d6d1b9..3817a90067 100644 --- a/pr-2023/using/backends/nvqc.html +++ b/pr-2023/using/backends/nvqc.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • diff --git a/pr-2023/using/backends/platform.html b/pr-2023/using/backends/platform.html index e3bddbda97..f0e3276ebf 100644 --- a/pr-2023/using/backends/platform.html +++ b/pr-2023/using/backends/platform.html @@ -124,7 +124,11 @@
  • Quantum States
  • Quantum Gates
  • Measurements
    • -
  • State Visualization
    • + + +
  • Visualization
  • Computing Expectation Values
    • +
  • Divisive Clustering With Coresets Using CUDA-Q +
  • Backends @@ -317,8 +330,8 @@
  • Building CUDA-Q
    • -
  • C++ Support
  • Python Support
    • +
  • C++ Support
  • Installation on the Host
  • Integration
  • Extending
      @@ -503,6 +522,7 @@
    • my
    • +
  • User-Defined Custom Operations
    • @@ -630,7 +650,8 @@

    Multi-Processor Platformscudaq algorithmic -primitive functions like sample and observe (e.g., sample_async function in the above code snippets).

    +primitive functions like sample, observe, and get_state +(e.g., sample_async function in the above code snippets).

    Depending on the number of GPUs available on the system, the nvidia multi-QPU platform will create the same number of virtual QPU instances. For example, on a system with 4 GPUs, the above code will distribute the four sampling tasks among those GPUEmulatedQPU instances.

    The results might look like the following 4 different random samplings:

    @@ -647,6 +668,77 @@

    Multi-Processor PlatformsCUDAQ_MQPU_NGPUS environment variable. For example, use export CUDAQ_MQPU_NGPUS=2 to specify that only 2 QPUs (GPUs) are needed.

    +

    Since the underlying GPUEmulatedQPU is a simulator backend, we can also retrieve the state vector from each +QPU via the cudaq::get_state_async (C++) or cudaq.get_state_async (Python) as shown in the bellow code snippets.

    +
    +
    +
    import cudaq
+
+cudaq.set_target("nvidia", option="mqpu")
+target = cudaq.get_target()
+qpu_count = target.num_qpus()
+print("Number of QPUs:", qpu_count)
+
+
+@cudaq.kernel
+def kernel():
+    qvector = cudaq.qvector(5)
+    # Place qubits in GHZ State
+    h(qvector[0])
+    for qubit in range(4):
+        x.ctrl(qvector[qubit], qvector[qubit + 1])
+
+
+state_futures = []
+for qpu in range(qpu_count):
+    state_futures.append(cudaq.get_state_async(kernel, qpu_id=qpu))
+
+for state in state_futures:
+    print(state.get())
+
    +
    +
    +
    +
      auto kernelToRun = [](int runtimeParam) __qpu__ {
+    cudaq::qvector q(runtimeParam);
+    h(q[0]);
+    for (int i = 0; i < runtimeParam - 1; ++i)
+      x<cudaq::ctrl>(q[i], q[i + 1]);
+  };
+
+  // Get the quantum_platform singleton
+  auto &platform = cudaq::get_platform();
+
+  // Query the number of QPUs in the system
+  auto num_qpus = platform.num_qpus();
+  printf("Number of QPUs: %zu\n", num_qpus);
+  // We will launch asynchronous tasks
+  // and will store the results immediately as a future
+  // we can query at some later point
+  std::vector<cudaq::async_state_result> stateFutures;
+  for (std::size_t i = 0; i < num_qpus; i++) {
+    stateFutures.emplace_back(
+        cudaq::get_state_async(i, kernelToRun, 5 /*runtimeParam*/));
+  }
+
+  //
+  // Go do other work, asynchronous execution of tasks on-going
+  //
+
+  // Get the results, note future::get() will kick off a wait
+  // if the results are not yet available.
+  for (auto &state : stateFutures) {
+    state.get().dump();
+  }
+
    +
    +

    One can specify the target multi-QPU architecture with the --target flag:

    +
    nvq++ get_state_async.cpp --target nvidia --target-option mqpu
+./a.out
+
    +
    +
    +

    Deprecated since version 0.8: The nvidia-mqpu and nvidia-mqpu-fp64 targets, which are equivalent to the multi-QPU options mgpu,fp32 and mgpu,fp64, respectively, of the nvidia target, are deprecated and will be removed in a future release.

    @@ -663,7 +755,7 @@

    Parallel distribution mode -
    +
    import cudaq
 from cudaq import spin
 
@@ -696,7 +788,7 @@ 
    Parallel distribution mode
    
+
    
 
      cudaq::mpi::initialize();
   using namespace cudaq::spin;
   cudaq::spin_op h = 5.907 - 2.1433 * x(0) * x(1) - 2.1433 * y(0) * y(1) +
@@ -736,7 +828,7 @@ 
    Remote MQP
 The following code illustrates how to launch asynchronous sampling tasks on multiple virtual QPUs,
 each simulated by a tensornet simulator backend.
    
 
    
-
    
+
    
 
        # Specified as program input, e.g.
     # ```
     # backend = "tensornet"; servers = "2"
@@ -785,7 +877,7 @@ 
    Remote MQP
 
    
 
    
 
    
-
    
+
    
 
      // Define a kernel to be sampled.
   auto [kernel, nrControls] = cudaq::make_kernel<int>();
   auto controls = kernel.qalloc(nrControls);
@@ -842,7 +934,7 @@ 
    Remote MQP
 For instance, on a machine with 8 NVIDIA GPUs, one may wish to partition those GPUs into
 4 virtual QPU instances, each manages 2 GPUs. To do so, first launch a cudaq-qpud server for each virtual QPU:
    
 
    
-
    
+
    
 
    # Use cudaq-qpud.py wrapper script to automatically find dependencies for the Python wheel configuration.
 cudaq_location=`python3 -m pip show cuda-quantum | grep -e 'Location: .*$'`
 qpud_py="${cudaq_location#Location: }/bin/cudaq-qpud.py"
@@ -853,7 +945,7 @@ 
    Remote MQP
 
    
 
    
 
    
-
    
+
    
 
    # It is assumed that your $LD_LIBRARY_PATH is able to find all the necessary dependencies.
 CUDA_VISIBLE_DEVICES=0,1 mpiexec -np 2 cudaq-qpud --port <QPU 1 TCP/IP port number>
 CUDA_VISIBLE_DEVICES=2,3 mpiexec -np 2 cudaq-qpud --port <QPU 2 TCP/IP port number>
@@ -876,12 +968,12 @@ 
    Remote MQP
 
    
 
    User code can then target these QPUs for multi-QPU workloads, such as asynchronous sample or observe shown above for the multi-QPU NVIDIA platform platform.
    
 
    
-
    
+
    
 
    cudaq.set_target("remote-mqpu", url="localhost:<port1>,localhost:<port2>,localhost:<port3>,localhost:<port4>", backend="nvidia-mgpu")
 
    
 
    
 
    
-
    
+
    
 
    nvq++ distributed.cpp --target remote-mqpu --remote-mqpu-url localhost:<port1>,localhost:<port2>,localhost:<port3>,localhost:<port4> --remote-mqpu-backend nvidia-mgpu
 
    
 
    
@@ -910,8 +1002,8 @@ 
    Supported Kernel Arguments
-
+
    Kernel argument serialization
    
+@@ -946,6 +1038,48 @@ 
    Supported Kernel Argumentsbool, integral (e.g., int or std::size_t), and floating-point types (float or double)
 when MLIR-based compilation is enabled (--enable-mlir).
    
 
+
    
+
    Accessing Simulated Quantum State
    
+
    The remote MQPU platform supports accessing simulator backend’s state vector via the
+cudaq::get_state (C++) or cudaq.get_state (Python) APIs, similar to local simulator backends.
    
+
    State data can be retrieved as a full state vector or as individual basis states’ amplitudes.
+The later is designed for large quantum states, which incurred data transfer overheads.
    
+
    
+
    
+
    state = cudaq.get_state(kernel)
+amplitudes = state.amplitudes(['0000', '1111'])
+
    
+
    
+
    
+
    
+
    auto state = cudaq::get_state(kernel)
+auto amplitudes = state.amplitudes({{0, 0, 0, 0}, {1, 1, 1, 1}});
+
    
+
    
+
    
+
    
+
    In the above example, the amplitudes of the two requested states are returned.
    
+
    For C++ quantum kernels [*] compiled with the CUDA-Q MLIR-based compiler and Python kernels,
+state accessor is evaluated in a just-in-time/on-demand manner, and hence can be customize to
+users’ need.
    
+
    For instance, in the above amplitude access example, if the state vector is very large, e.g.,
+multi-GPU distributed state vectors or tensor-network encoded quantum states, the full state vector
+will not be retrieved when get_state is called. Instead, when the amplitudes accessor is called,
+a specific amplitude calculation request will be sent to the server.
+Thus, only the amplitudes of those basis states will be computed and returned.
    
+
    Similarly, for state overlap calculation, if deferred state evaluation is available (Python/MLIR-based compiler)
+for both of the operand quantum states, a custom overlap calculation request will be constructed and sent to the server.
+Only the final overlap result will be returned, thereby eliminating back-and-forth state data transfers.
    
+
+
    
 
 
 
diff --git a/pr-2023/using/backends/simulators.html b/pr-2023/using/backends/simulators.html
index 64ce28126c..bf76e6060d 100644
--- a/pr-2023/using/backends/simulators.html
+++ b/pr-2023/using/backends/simulators.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/basics/basics.html b/pr-2023/using/basics/basics.html
index bf45c3e555..8a6b82f58e 100644
--- a/pr-2023/using/basics/basics.html
+++ b/pr-2023/using/basics/basics.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/basics/build_kernel.html b/pr-2023/using/basics/build_kernel.html
index 7a2560fde6..3632a3d7c1 100644
--- a/pr-2023/using/basics/build_kernel.html
+++ b/pr-2023/using/basics/build_kernel.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/basics/kernel_intro.html b/pr-2023/using/basics/kernel_intro.html
index ff1f3896e2..f643cc5788 100644
--- a/pr-2023/using/basics/kernel_intro.html
+++ b/pr-2023/using/basics/kernel_intro.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/basics/run_kernel.html b/pr-2023/using/basics/run_kernel.html
index 1f8466eacc..bd5e8b204a 100644
--- a/pr-2023/using/basics/run_kernel.html
+++ b/pr-2023/using/basics/run_kernel.html
@@ -126,7 +126,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -319,8 +332,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -505,6 +524,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/basics/troubleshooting.html b/pr-2023/using/basics/troubleshooting.html
index d0c986a329..dd7a43ebd9 100644
--- a/pr-2023/using/basics/troubleshooting.html
+++ b/pr-2023/using/basics/troubleshooting.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/examples/bernstein_vazirani.html b/pr-2023/using/examples/bernstein_vazirani.html
index 99709ddceb..c9549fec1b 100644
--- a/pr-2023/using/examples/bernstein_vazirani.html
+++ b/pr-2023/using/examples/bernstein_vazirani.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/examples/cuquantum.html b/pr-2023/using/examples/cuquantum.html
index c47bc7dbea..a873ef2a9b 100644
--- a/pr-2023/using/examples/cuquantum.html
+++ b/pr-2023/using/examples/cuquantum.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/examples/examples.html b/pr-2023/using/examples/examples.html
index f6d87368a1..900670f2db 100644
--- a/pr-2023/using/examples/examples.html
+++ b/pr-2023/using/examples/examples.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
@@ -544,6 +564,7 @@ 
    CUDA-Q by Example   Introduction
 
  •    Quantum Operations
    • 
+
  •    Visualization
    • 
 
  •    Computing Expectation Values
    • 
 
  •    Multi-Control Synthesis
    • 
 
  •    Multi-GPU Workflows
    • 
diff --git a/pr-2023/using/examples/expectation_values.html b/pr-2023/using/examples/expectation_values.html
index 1afb3926d9..5349cb8e4b 100644
--- a/pr-2023/using/examples/expectation_values.html
+++ b/pr-2023/using/examples/expectation_values.html
@@ -30,7 +30,7 @@
     
     
     
-     
+     
 
 
  
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
@@ -530,7 +550,7 @@
              View page source
       
   
   
    
@@ -707,7 +727,7 @@ 
    Parallelizing across Multiple Processors
-        
+        
         
     
 
diff --git a/pr-2023/using/examples/hardware_providers.html b/pr-2023/using/examples/hardware_providers.html
index 5d56470392..901884433c 100644
--- a/pr-2023/using/examples/hardware_providers.html
+++ b/pr-2023/using/examples/hardware_providers.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
@@ -816,7 +836,6 @@ 
    OQC
 
    
 
    import cudaq
-import os
 
 # You only have to set the target once! No need to redefine it
 # for every execution call on your kernel.
diff --git a/pr-2023/using/examples/introduction.html b/pr-2023/using/examples/introduction.html
index f8b97c77c5..27b1488bfe 100644
--- a/pr-2023/using/examples/introduction.html
+++ b/pr-2023/using/examples/introduction.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/examples/multi_control.html b/pr-2023/using/examples/multi_control.html
index 4555c746fb..dcfa239618 100644
--- a/pr-2023/using/examples/multi_control.html
+++ b/pr-2023/using/examples/multi_control.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/examples/multi_gpu_workflows.html b/pr-2023/using/examples/multi_gpu_workflows.html
index 0f3727f871..64b380318b 100644
--- a/pr-2023/using/examples/multi_gpu_workflows.html
+++ b/pr-2023/using/examples/multi_gpu_workflows.html
@@ -126,7 +126,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -319,8 +332,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -505,6 +524,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/examples/noisy_simulation.html b/pr-2023/using/examples/noisy_simulation.html
index 6ff6f25b80..d417f1eb10 100644
--- a/pr-2023/using/examples/noisy_simulation.html
+++ b/pr-2023/using/examples/noisy_simulation.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/examples/qaoa.html b/pr-2023/using/examples/qaoa.html
index e6c1dc5619..7132aadeab 100644
--- a/pr-2023/using/examples/qaoa.html
+++ b/pr-2023/using/examples/qaoa.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/examples/quantum_operations.html b/pr-2023/using/examples/quantum_operations.html
index 218733955b..0536182728 100644
--- a/pr-2023/using/examples/quantum_operations.html
+++ b/pr-2023/using/examples/quantum_operations.html
@@ -31,7 +31,7 @@
     
     
     
-    
+    
      
 
 
@@ -126,7 +126,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -319,8 +332,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -505,6 +524,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
@@ -533,7 +553,7 @@
       
   
   
    
 
    
@@ -734,26 +754,6 @@ 
    Measurements\(\sum_{x \in \{ 0,1 \}^2} \lvert \alpha_{x} \rvert ^2 = 1\).
    
 
-
    
-
    State Visualization
    
-
    What are the possible states a qubit can be in and how can we build up
-a visual cue to help us make sense of quantum states and their
-evolution?
    
-
    We know our qubit can have two distinct states: \(\ket{0}\) and
-\(\ket{1}\). Maybe we need a one-dimensional line whose vertices can
-represent each of the aforementioned states.
-We also know that qubits can be in an equal superposition states:
-\(\ket{+}\) and \(\ket{-}\). This now forces us to extend our
-1D line to a 2D Cartesian coordinate system.
-If you dive deeper you will learn about the existence of states like
-\(\ket{+i}\) and \(\ket{-i}\), this calls for a 3D
-extension.
    
-
    It turns out that a sphere is able to depict all the possible states of
-a single qubit. This is called a Bloch sphere.
    
-
    Unfortunately, there is no such handy visualization for multi-qubit states.
-In particular, a multi-qubit state cannot be visualized as multiple Bloch
-spheres due to the nature of entanglement that makes quantum computing so powerful.
    
-
    
 
 
 
@@ -761,7 +761,7 @@ 
    State Visualization
         
-        
+        
     
    
 
   
    
diff --git a/pr-2023/using/examples/vqe.html b/pr-2023/using/examples/vqe.html
index 03234b268c..b2fa95793b 100644
--- a/pr-2023/using/examples/vqe.html
+++ b/pr-2023/using/examples/vqe.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/extending/cudaq_ir.html b/pr-2023/using/extending/cudaq_ir.html
index f0bc68ee57..ba9fdc4dfb 100644
--- a/pr-2023/using/extending/cudaq_ir.html
+++ b/pr-2023/using/extending/cudaq_ir.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/extending/extending.html b/pr-2023/using/extending/extending.html
index 3fd380bdbc..9471d3b54a 100644
--- a/pr-2023/using/extending/extending.html
+++ b/pr-2023/using/extending/extending.html
@@ -30,7 +30,7 @@
     
     
     
-     
+     
 
 
  
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
@@ -529,7 +549,7 @@
              View page source
       
   
   
    
@@ -552,7 +572,7 @@ 
    Extending CUDA-Q
-        
+        
         
     
    
 
diff --git a/pr-2023/using/extending/mlir_pass.html b/pr-2023/using/extending/mlir_pass.html
index 06ca372387..389cde4c0f 100644
--- a/pr-2023/using/extending/mlir_pass.html
+++ b/pr-2023/using/extending/mlir_pass.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/extending/nvqir_simulator.html b/pr-2023/using/extending/nvqir_simulator.html
index add4e55c7a..a5cca464b5 100644
--- a/pr-2023/using/extending/nvqir_simulator.html
+++ b/pr-2023/using/extending/nvqir_simulator.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/install/data_center_install.html b/pr-2023/using/install/data_center_install.html
index 0e58c82d53..9e7a003232 100644
--- a/pr-2023/using/install/data_center_install.html
+++ b/pr-2023/using/install/data_center_install.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
@@ -551,12 +571,15 @@ 
    Installation from Sourceconnect an IDE to a running container.
    
 
    If you do not want use a container runtime, we also provide pre-built binaries
-for using CUDA-Q with C++. These binaries are built following the instructions
+for using CUDA-Q with C++, and Python wheels for using CUDA-Q with Python.
+These binaries and wheels are built following the instructions
 in this guide and should work for you as long as your system meets the compatibility
 requirements listed under Prerequisites.
-To install them, please follow the instructions here.
    
-
    If our pre-built packages are not a good option for you, e.g. because you would
-like to use CUDA-Q on an operating system that is not officially supported,
+To install the pre-built binaries, please follow the instructions
+here. To install the Python wheels, please
+follow the instructions here.
    
+
    If your system is not listed as supported by our official packages, e.g. because you would
+like to use CUDA-Q on an operating system that uses an older C standard library,
 please follow this guide carefully without skipping any steps to build and install
 CUDA-Q from source. The rest of this guide details system requirements
 during the build and after installation, and walks through the installation steps.
    
@@ -671,10 +694,12 @@ 
    Build Dependencies
 
    CUDA
    
 
    Building CUDA-Q requires a full installation of the CUDA toolkit.
+You can install the CUDA toolkit and use the CUDA compiler without having a GPU.
 The instructions are tested using version 11.8, but any CUDA 11 or 12 version
-should work, as long as the installed driver on the host
+should work, as long as the CUDA runtime version on the host system matches the
+CUDA version used for the build, and the installed driver on the host
 system supports that CUDA version. We recommend using the latest CUDA version
-that is supported by your driver.
    
+that is supported by the driver on the host system.
    
 
    Download a suitable CUDA version
 following the installation guide for your platform in the online documentation
 linked on that page.
    
@@ -694,38 +719,38 @@ 
    CUDA¶<
 
 
    
 
    Toolchain
    
-
    The compiler toolchain used for the build needs to support C++20 and must be a supported
+
    The compiler toolchain used for the build must be a supported
 CUDA host compiler
 for the installed CUDA version.
-The following instructions have been tested with
-GCC-11 as your toolchain for building CUDA-Q.
-If you use a different compiler, we recommend using an OpenMP-enabled compiler. At this
-time, we actively test building with GCC 11 and 12, as well as with Clang 16.
+The following instructions have been tested with GCC-11.
 Other toolchains may be supported but have not been tested.
    
 
    Within the tested AlmaLinux 8 environment, for example, the following commands
 install GCC 11:
    
 
    GCC_VERSION=11
 dnf install -y --nobest --setopt=install_weak_deps=False \
     gcc-toolset-${GCC_VERSION}
+# Enabling the toolchain globally is only needed for debug builds
+# to ensure that the correct assembler is picked to process debug symbols.
+enable_script=`find / -path '*gcc*' -path '*'$GCC_VERSIONS'*' -name enable`
+if [ -n "$enable_script" ]; then
+    . "$enable_script"
+fi
 
    
 
    
 
    Independent on which compiler toolchain you installed, set the following
 environment variables to point to the respective compilers on your build system:
    
-
    GCC_INSTALL_PREFIX=/opt/rh/gcc-toolset-11
-export CXX="${GCC_INSTALL_PREFIX}/root/usr/bin/g++"
-export CC="${GCC_INSTALL_PREFIX}/root/usr/bin/gcc"
-export FC="${GCC_INSTALL_PREFIX}/root/usr/bin/gfortran"
+
    export GCC_TOOLCHAIN=/opt/rh/gcc-toolset-11/root/usr/
+export CXX="${GCC_TOOLCHAIN}/bin/g++"
+export CC="${GCC_TOOLCHAIN}/bin/gcc"
 export CUDACXX=/usr/local/cuda/bin/nvcc
+export CUDAHOSTCXX="${GCC_TOOLCHAIN}/bin/g++"
 
    
 
    
 
      
 
    • The variables CC and CXX must be set for the CUDA-Q build.
      • 
-
    • A Fortran compiler is needed (only) to build the OpenSSL dependency;
-if you have an existing OpenSSL installation that you set the
-OPENSSL_INSTALL_PREFIX variable to, you can omit setting the FC
-environment variable.
      • 
 
    • To use GPU-acceleration in CUDA-Q, make sure to set CUDACXX to
-your CUDA compiler. If the CUDA compiler is not found when building
+your CUDA compiler, and CUDAHOSTCXX to the CUDA compatible host
+compiler you are using. If the CUDA compiler is not found when building
 CUDA-Q, some components and backends will be omitted automatically
 during the build.
      • 
 
    
@@ -741,11 +766,10 @@ 
    Building CUDA-Qnvidia.config exists in the $CUDAQ_INSTALL_PREFIX/targets folder.
+We also recommend checking the build log printed to the console to confirm that all desired
+components have been built.
    
 
    
 
    Note
    
 
    The CUDA-Q build will compile or omit optional components automatically depending
@@ -756,50 +780,13 @@ 
    Building CUDA-Q
-
    C++ Support
    
-
    From within the folder where you cloned the CUDA-Q repository, run the following
-command to build CUDA-Q:
    
-
    CUDAQ_WERROR=false \
-CUDAQ_PYTHON_SUPPORT=OFF \
-CUDAHOSTCXX="$CXX" \
-LDFLAGS='-static-libgcc -static-libstdc++' \
-LLVM_PROJECTS='clang;lld;mlir' \
-bash scripts/build_cudaq.sh -uv
-
    
-
    
-
    Note that lld is primarily needed when the build or host system does not already have an existing default linker on its path; CUDA-Q supports the same linkers as clang does.
    
-
    To easily migrate the built binaries to the host system, we recommend creating a
-self-extracting archive. To do so, download the
-makeself script(s) and move the necessary
-files to install into a separate folder using the command
    
-
    mkdir -p cuda_quantum_assets/llvm/bin && mkdir -p cuda_quantum_assets/llvm/lib && \
-mv "${LLVM_INSTALL_PREFIX}/bin/"clang* cuda_quantum_assets/llvm/bin/ && \
-mv "${LLVM_INSTALL_PREFIX}/lib/"clang* cuda_quantum_assets/llvm/lib/ && \
-mv "${LLVM_INSTALL_PREFIX}/bin/llc" cuda_quantum_assets/llvm/bin/llc && \
-mv "${LLVM_INSTALL_PREFIX}/bin/lld" cuda_quantum_assets/llvm/bin/lld && \
-mv "${LLVM_INSTALL_PREFIX}/bin/ld.lld" cuda_quantum_assets/llvm/bin/ld.lld && \
-mv "${CUTENSOR_INSTALL_PREFIX}" cuda_quantum_assets && \
-mv "${CUQUANTUM_INSTALL_PREFIX}" cuda_quantum_assets && \
-mv "${CUDAQ_INSTALL_PREFIX}/build_config.xml" cuda_quantum_assets/build_config.xml && \
-mv "${CUDAQ_INSTALL_PREFIX}" cuda_quantum_assets
-
    
-
    
-
    You can then create a self-extracting archive with the command
    
-
    ./makeself.sh --gzip --sha256 --license cuda_quantum_assets/cudaq/LICENSE \
-    cuda_quantum_assets install_cuda_quantum.$(uname -m) \
-    "CUDA-Q toolkit for heterogeneous quantum-classical workflows" \
-    bash cudaq/migrate_assets.sh -t /opt/nvidia/cudaq
-
    
-
    
-
    
 
    
 
    Python Support
    
 
    The most convenient way to enable Python support within CUDA-Q is to build
 a wheel that can then easily be installed
 using pip. To ensure the wheel can be installed on the host system, make sure to
 use the same Python version for the build as the one that is installed on the host system.
-To build the CUDA-Q Python wheel, you will need to install the following additional
+To build a CUDA-Q Python wheel, you will need to install the following additional
 Python-specific tools:
    
 
    
+
    
+
    C++ Support
    
+
    From within the folder where you cloned the CUDA-Q repository, run the following
+command to build CUDA-Q:
    
+
    CUDAQ_ENABLE_STATIC_LINKING=TRUE \
+CUDAQ_REQUIRE_OPENMP=TRUE \
+CUDAQ_WERROR=TRUE \
+CUDAQ_PYTHON_SUPPORT=OFF \
+LLVM_PROJECTS='clang;flang;lld;mlir;openmp;runtimes' \
+bash scripts/build_cudaq.sh -t llvm -v
+
    
+
    
+
    Note that lld is primarily needed when the build or host system does not already
+have an existing default linker on its path; CUDA-Q supports the same linkers as
+clang does.
    
+
    To easily migrate the built binaries to the host system, we recommend creating a
+self-extracting archive. To do so, download the
+makeself script(s) and move the necessary
+files to install into a separate folder using the command
    
+
    mkdir -p cuda_quantum_assets/llvm/bin && \
+mkdir -p cuda_quantum_assets/llvm/lib && \
+mkdir -p cuda_quantum_assets/llvm/include && \
+mv "${LLVM_INSTALL_PREFIX}/bin/"clang* cuda_quantum_assets/llvm/bin/ && \
+mv cuda_quantum_assets/llvm/bin/clang-format* "${LLVM_INSTALL_PREFIX}/bin/" && \
+mv "${LLVM_INSTALL_PREFIX}/bin/llc" cuda_quantum_assets/llvm/bin/llc && \
+mv "${LLVM_INSTALL_PREFIX}/bin/lld" cuda_quantum_assets/llvm/bin/lld && \
+mv "${LLVM_INSTALL_PREFIX}/bin/ld.lld" cuda_quantum_assets/llvm/bin/ld.lld && \
+mv "${LLVM_INSTALL_PREFIX}/lib/"* cuda_quantum_assets/llvm/lib/ && \
+mv "${LLVM_INSTALL_PREFIX}/include/"* cuda_quantum_assets/llvm/include/ && \
+mv "${CUTENSOR_INSTALL_PREFIX}" cuda_quantum_assets && \
+mv "${CUQUANTUM_INSTALL_PREFIX}" cuda_quantum_assets && \
+mv "${CUDAQ_INSTALL_PREFIX}/build_config.xml" cuda_quantum_assets/build_config.xml && \
+mv "${CUDAQ_INSTALL_PREFIX}" cuda_quantum_assets
+
    
+
    
+
    You can then create a self-extracting archive with the command
    
+
    ./makeself.sh --gzip --sha256 --license cuda_quantum_assets/cudaq/LICENSE \
+    cuda_quantum_assets install_cuda_quantum.$(uname -m) \
+    "CUDA-Q toolkit for heterogeneous quantum-classical workflows" \
+    bash cudaq/migrate_assets.sh -t /opt/nvidia/cudaq
+
    
+
    
+
    
 
    
 
    Installation on the Host
    
 
    Make sure your host system satisfies the Prerequisites listed above.
    
 
      
-
    • To use CUDA-Q with C++, you should also make sure that the
-C++ standard library
-is installed and discoverable on your host system.
-CUDA-Q supports the GNU C++ standard library (libstdc++),
-version 11 or newer. Other libraries may work but can cause issues in certain cases.
      • 
 
    • To use CUDA-Q with Python, you should have a working
 Python installation on the host system, including the pip package manager.
      • 
-
    
+
  • To use CUDA-Q with C++, you should make sure that you have the necessary development
+headers of the C standard library installed. You can check this by searching for
+features.h, commonly found in /usr/include/. You can install the necessary headers
+via package manager (usually the package name is called something like glibc-devel
+or libc6-devel). These headers are also included with any installation of GCC.
    • 
+
+
    To use CUDA-Q with Python, you should have a working
+Python installation on the host system, including the pip package manager.
    
 
    If you followed the instructions for building the
 CUDA-Q Python wheel,
 copy the built .whl file to the host system, and install it using pip; e.g.
    
@@ -900,9 +936,13 @@ 
    Installation on the Host
 
    Note
    
-
    CUDA-Q includes its own linker, specifically the LLD
-linker. You can customize which linker the nvq++ compiler uses by setting the
-NVQPP_LD_PATH environment variable; for example export NVQPP_LD_PATH=ld.
    
+
    CUDA-Q as built following the instructions above includes and uses the LLVM
+C++ standard library. This will not interfere with any other C++ standard library
+you may have on your system. Pre-built external libraries, you may want to use with
+CUDA-Q, such as specific optimizers for example, have a C API to ensure compatibility
+across different versions of the C++ standard library and will work with CUDA-Q without
+issues. The same is true for all distributed CUDA libraries. To build you own CUDA
+libraries that can be used with CUDA-Q, please take a look at Using CUDA and CUDA-Q in a Project.
    
 
 
    The remaining sections in this document list additional runtime dependencies
 that are not included in the migrated assets and are needed to use some of the
@@ -910,7 +950,8 @@ 
    Installation on the Host
 
    CUDA Runtime Libraries
    
 
    To use GPU-acceleration in CUDA-Q you will need to install the necessary
-CUDA runtime libraries. While not necessary, we recommend installing
+CUDA runtime libraries. Their version (at least the version major) needs to match the version
+used for the build. While not necessary, we recommend installing
 the complete CUDA toolkit like you did for the CUDA-Q build.
 If you prefer to only install the minimal set of runtime libraries, the following
 commands, for example, install the necessary packages for the AlmaLinux 8 environment:
    
diff --git a/pr-2023/using/install/install.html b/pr-2023/using/install/install.html
index 3a87b092d6..3c0d117961 100644
--- a/pr-2023/using/install/install.html
+++ b/pr-2023/using/install/install.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/install/local_installation.html b/pr-2023/using/install/local_installation.html
index 88efca901d..61c9df45ab 100644
--- a/pr-2023/using/install/local_installation.html
+++ b/pr-2023/using/install/local_installation.html
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
@@ -734,13 +754,15 @@ 
    Introduction
 
    Note
    
-
    To use GPU-accelerated backends, you will need to install the necessary CUDA runtime libraries. For more information see the corresponding section on Additional CUDA Tools.
    
+
    To use GPU-accelerated backends, you will need to install the necessary CUDA runtime libraries.
+For more information see the corresponding section on
+Additional CUDA Tools.
    
 
 
    The installation ensures that the necessary environment variables for
 using the CUDA-Q toolchain are set upon login for all POSIX shells.
 Confirm that the nvq++ command is found. If it is not, please make sure
 to set the environment variables defined by the set_env.sh script in the
-CUDA-Q installation folder (usually /opt/nvidia/cudaq).
    
+CUDA-Q installation folder (usually /usr/local/cudaq or /opt/nvidia/cudaq).
    
 
    If an MPI installation is available in the directory defined by MPI_PATH,
 the installer automatically enables MPI support in CUDA-Q.
 If you do not have MPI installed on your system, you can simply
@@ -752,20 +774,18 @@ 
    Introductionbash "${CUDA_QUANTUM_PATH}/distributed_interfaces/activate_custom_mpi.sh"
 
 
-
    To develop C++ code, you most likely also want to install the
-C++ standard library.
-CUDA-Q supports the GNU C++ standard library (libstdc++),
-version 11 or newer. Other libraries may work but can cause issues in certain cases.
-The C++ standard library, including development headers, is almost certainly
-available via the package manager for your system. To ensure the libraries and headers
-are discoverable, the easiest option is usually to install the complete GCC toolchain.
-Note that for certain distributions, you may need to manually enable that version
-after installation by running a script called enable. You can search for such a
-script with the command find / -path '*gcc*' -name enable.
    
+
    
+
    Note
    
+
    Please make sure that you have the necessary development headers of the C standard
+library installed. You can check this by searching for features.h, commonly found
+in /usr/include/. You can install the necessary headers via package manager
+(usually the package name is called something like glibc-devel or libc6-dev).
+These headers are also included with any installation of GCC.
    
+
    
 
    
 
 
    
-
    Development with VS Code
    
+
    Development with VS Code
    
 
    To facilitate application development with, for example, debugging, code completion, hover information, and so on,
 we recommend using VS Code. VS Code provides a seamless
 development experience on all platforms, and is also available without installation via web browser.
@@ -1085,7 +1105,7 @@ 
    Installation In Container Images
 
    Installing Pre-built Binaries
    
 
    If you installed pre-built binaries for CUDA-Q, you will need to install
-the necessary CUDA runtime libraries to use GPU-acceleration in CUDA-Q.
+the necessary CUDA 11 runtime libraries to use GPU-acceleration in CUDA-Q.
 If you prefer to only install the minimal set of runtime libraries, the following
 commands, for example, install the necessary packages for RHEL 8:
    
 
    CUDA_VERSION=11.8
@@ -1102,8 +1122,8 @@ 
    Installation In Container ImagesCUDA version.
-Please make sure to install CUDA version 11.8 or newer, and confirm that your
+linked for that CUDA version.
+Please make sure to install CUDA version 11.8, and confirm that your
 GPU driver supports that version.
 While the above packages are sufficient to use GPU-acceleration within CUDA-Q,
 we recommend installing the complete CUDA toolkit (cuda-toolkit-11-8) that also
diff --git a/pr-2023/using/integration/cmake_app.html b/pr-2023/using/integration/cmake_app.html
index cb02b6c47d..5f590a83c3 100644
--- a/pr-2023/using/integration/cmake_app.html
+++ b/pr-2023/using/integration/cmake_app.html
@@ -29,8 +29,8 @@
     
     
     
-    
-     
+    
+     
 
 
  
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
@@ -530,8 +550,8 @@
              View page source
       
   
   
    
 
    
@@ -575,8 +595,8 @@ 
    CUDA-Q and CMake
-        
-        
+        
+        
     
    
 
   
    
diff --git a/pr-2023/using/integration/cuda_gpu.html b/pr-2023/using/integration/cuda_gpu.html
index 3d55a744eb..39dbb6d43e 100644
--- a/pr-2023/using/integration/cuda_gpu.html
+++ b/pr-2023/using/integration/cuda_gpu.html
@@ -29,8 +29,8 @@
     
     
     
-    
-     
+    
+     
 
 
  
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
@@ -530,8 +550,8 @@
              View page source
       
   
   
    
 
@@ -556,18 +576,82 @@ 
    Using CUDA and CUDA-Q in a Project.cpp extension. Again for our
 example, let’s assume that we’ve written quantum kernels and saved
 them in the file my_proj_quantum.cpp.
    
-
    There is a bit of a wrinkle to be aware of before we compile these two
-compilation units. Version 11 (and earlier) of CUDA nvcc
-supports the C++ 11, 14, and 17 standards and the default standard is
-determined by the host C++ compiler. The CUDA-Q compiler,
-nvq++, defaults to the C++ 20 standard. To get around this
-limitation, the project makefiles should select a common C++ standard
-version. Fortunately, nvq++ does allow the use of C++ 17.
    
-
    Note that starting with version 12 of the CUDA toolkit, the C++ 20
-standard is supported.
    
-
    Our project can then be built with commands such as
    
-
    nvcc -c -std=c++17 <options> my_proj.cu -o my_proj.o
-nvq++ -std=c++17 <options> my_project_quantum.cpp my_proj.o -L ${CUDA_INSTALL}/lib64 -lcudart -o my_executable
+
    By default, CUDA-Q uses C++ 20 and builds source code against the
+LLVM C++ standard library (libc++). To create a CUDA library that
+can link against CUDA-Q code, make sure to define an API that does
+not rely on C++ data structures that rely on a specific C++ toolchain
+for all functions intended to be called from CUDA-Q (see also
+Interfacing between binaries compiled with a different toolchains). For example, if you define a CUDA kernel in my_proj.cu
    
+
    template <typename CudaDataType>
+__global__ void cudaSetFirstNElements(CudaDataType *sv, const CudaDataType *__restrict__ sv2, int64_t N) {
+int64_t i = static_cast<int64_t>(blockIdx.x) * blockDim.x + threadIdx.x;
+    if (i < N) {
+        sv[i].x = sv2[i].x;
+        sv[i].y = sv2[i].y;
+    } else {
+        sv[i].x = 0.0;
+        sv[i].y = 0.0;
+    }
+}
+
    
+
    
+
    define the following template and all desired template specializations
    
+
    template <typename CudaDataType>
+void setFirstNElements(uint32_t n_blocks,
+                       int32_t threads_per_block,
+                       void *newDeviceStateVector,
+                       void *deviceStateVector,
+                       std::size_t previousStateDimension) {
+    cudaSetFirstNElements<<<n_blocks, threads_per_block>>>(
+        reinterpret_cast<CudaDataType *>(newDeviceStateVector),
+        reinterpret_cast<CudaDataType *>(deviceStateVector),
+        previousStateDimension);
+}
+
+template void
+setFirstNElements<cuFloatComplex>(uint32_t n_blocks,
+                                  int32_t threads_per_block,
+                                  void *newDeviceStateVector,
+                                  void *deviceStateVector,
+                                  std::size_t previousStateDimension);
+
+template void
+setFirstNElements<cuDoubleComplex>(uint32_t n_blocks,
+                                   int32_t threads_per_block,
+                                   void *newDeviceStateVector,
+                                   void *deviceStateVector,
+                                   std::size_t previousStateDimension);
+
    
+
    
+
    Create the corresponding header file my_proj.h declaring the setFirstNElements
+template. You can then call setFirstNElements from within my_proj_quantum.cpp
+by including my_proj.h, for example
    
+
    #include "cuComplex.h"
+#include "cuda_runtime.h"
+#include "device_launch_parameters.h"
+#include "my_proj.h"
+
+using namespace my_kernels; // the namespace where you defined setFirstNElements
+
+int main () {
+    const uint32_t n_blocks = 10;
+    const uint32_t threads_per_block = 5;
+
+    void *deviceStateVector;
+    cudaMalloc((void **)&deviceStateVector, 2 * sizeof(cuDoubleComplex));
+    // ...
+    void *newDeviceStateVector;
+    cudaMalloc((void **)&newDeviceStateVector, 2 * sizeof(cuDoubleComplex));
+    setFirstNElements<cuDoubleComplex>(n_blocks, threads_per_block,
+                                       newDeviceStateVector, deviceStateVector,
+                                       2);
+    return 0;
+}
+
    
+
    
+
    To get an executable, compile the code with
    
+
    nvcc -c -std=c++17 -Xcompiler -fPIC my_proj.cu -o my_proj.o
+nvq++ my_proj_quantum.cpp my_proj.o -I"${CUDA_HOME}/include/" -L"${CUDA_HOME}/lib64" -lcudart -o my_executable
 
    
 
    
 
    Above, nvq++ is used for the link step and will make sure the CUDA-Q
@@ -579,8 +663,8 @@ 
    Using CUDA and CUDA-Q in a Project
-        
-        
+        
+        
     
    
 
   
    
diff --git a/pr-2023/using/integration/integration.html b/pr-2023/using/integration/integration.html
index e05cfea930..e4310b35a0 100644
--- a/pr-2023/using/integration/integration.html
+++ b/pr-2023/using/integration/integration.html
@@ -29,7 +29,7 @@
     
     
     
-    
+    
      
 
 
@@ -124,7 +124,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -317,8 +330,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -503,6 +522,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
@@ -530,7 +550,7 @@
       
   
   
    
 
    
@@ -541,8 +561,9 @@
 
    Integration with other Software Tools
    
 
    
 
 
    
 
    Information about customizing or extending the CUDA-Q toolchain can be found in Extending CUDA-Q.
    
@@ -553,7 +574,7 @@ 
    Integration with other Software Tools
         
-        
+        
     
 
   
    
diff --git a/pr-2023/using/integration/libraries.html b/pr-2023/using/integration/libraries.html
new file mode 100644
index 0000000000..d6470b98df
--- /dev/null
+++ b/pr-2023/using/integration/libraries.html
@@ -0,0 +1,803 @@
+
+
+
+  
+
+  
+  Integrating with Third-Party Libraries — NVIDIA CUDA-Q  documentation
+      
+      
+      
+      
+      
+      
+      
+  
+  
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+    
+    
+    
+    
+     
+
+
+ 
+  
    
+    
+
+    
    
+
+      
    
+        
    
+          
    
+  
+  
    
+
    
+          
    
+           
    
+             
+  
    
+
    Integrating with Third-Party Libraries
    
+
    CUDA-Q enables easily integrating quantum kernels with existing state-of-the-art tools
+for classical computing and high performance computing. While quantum kernels are expressed
+in Python or C++, quantum hardware backends only support a very limited set of classical
+instructions. Correspondingly, only a select set of libraries and functions that are
+directly supported by the CUDA-Q compiler can be called from within quantum kernels.
+Code that is not marked as kernel code, on the other hand, can be used to invoke the
+defined quantum kernels as well as any classical tools and libraries. CUDA-Q provides
+a complete toolset to build complex applications running on multi-processor systems involving
+CPUs, GPUs and QPUs.
    
+
    In Python, integration with any third-party Python package is handled
+automatically without any need for additional configuration. For C++, the rest of this
+document outlines how to integration with libraries that are compile with a different
+compiler than nvq++.
    
+
    
+
    Calling a CUDA-Q library from C++
    
+
    The CUDA-Q compiler is a fully-featured C++ compiler able to process arbitrary C++ code outside
+of quantum kernels. In fact, the CUDA-Q installation includes and invokes a custom-built Clang
+compiler under the hood. In general, it hence is not necessary to use a different compiler to
+compile C++ host code that calls into quantum kernels; the host code is compiled along with
+the quantum kernels into a single library or executable by the CUDA-Q toolchain.
    
+
    If you would still like to create a library that can be included in libraries and executables
+built with a different toolchain, you can configure nvq++ to include and encapsulate all its
+C++ dependencies, such that the CUDA-Q library only depends on C libraries. For example,
+if you have a file quantum_kernel.cpp containing
    
+
    #include "cudaq.h"
+#include <iostream>
+#include <sstream>
+
+namespace quantum {
+
+__qpu__ void bell() {
+  cudaq::qvector qs(2);
+  h(qs[0]);
+  cnot(qs[0], qs[1]);
+  mz(qs);
+}
+
+// Usually, one would probably return something like
+// the most probably value in the distribution rather
+// than the string dump. However, the bell kernel here
+// has a 50/50 chance of returning 00 or 11.
+const char* bell_distribution() {
+  auto dist = cudaq::sample(bell);
+
+  std::stringbuf buffer;
+  std::ostream os(&buffer);
+  dist.dump(os);
+  auto sample_results = buffer.str();
+
+  char* ptr = new char[sample_results.size() + 1];
+  strcpy(ptr, sample_results.c_str());
+  return ptr;
+}
+
+} // namespace quantum
+
    
+
    
+
    you can create such a library with the command
    
+
    nvq++ quantum_kernel.cpp -shared -static-libstdc++ -fPIC -o libquantum_kernel.so
+
    
+
    
+
    To use this library in a project built with an external toolchain, define a suitable
+header file quantum_kernel.h containing
    
+
    namespace quantum {
+  const char* bell_distribution();
+}
+
    
+
    
+
    and include it in your project. For example, if external.cpp contains
    
+
    #include <iostream>
+#include "quantum_kernel.h"
+
+int main () {
+  // some code
+  auto bell_dist = quantum::bell_distribution();
+  std::cout << bell_dist << std::endl;
+  delete[] bell_dist;
+  // more code
+  return 0;
+}
+
    
+
    
+
    you can compile it with g++ and link it with the built libquantum_kernel.so library
+using the command
    
+
    g++ external.cpp -lquantum_kernel -L"$(pwd)" -Wl,-rpath="$(pwd)" -I"$(pwd)"
+
    
+
    
+
    Note that the API defined in quantum_kernel.h does not depend on any data types that
+rely on the specific implementation of the C++ standard library. For example, we return a
+const char* instead of a std::string value. This is important to ensure that the data
+is handled correctly regardless of which C++ standard library is used. If you include
+data types that depend on a specific C++ ABI, the linker should detect this incompatibility
+and should generate an error. See the section Interfacing between binaries compiled with a different toolchains below to learn more about
+what to watch out for when defining an API to interface between libraries that are built
+with different compilers.
    
+
    
+
    
+
    Calling an C++ library from CUDA-Q
    
+
    CUDA-Q comes with a complete C++ toolchain, and is configured to use its own C++ standard
+library by default. When calling a third-party library from within a CUDA-Q application,
+the quantum kernels and the surrounding application code are compiled with the nvq++ compiler,
+whereas the third-party library may be compiled with a different toolchain.
+For most widely distributed libraries, this will work out of the box. The exception are
+third-party libraries that are pre-compiled (opposed to being header-only libraries)
+and dynamically depend on a different C++ standard library than CUDA-Q uses.
+This is the case for a library third_party_library.so if libstdc++.so is listed
+in the output of the command
    
+
    ldd third_party_library.so
+
    
+
    
+
    To use such a library with CUDA-Q, you have to install the static version of the
+library. The nvq++ compiler can be configured to link a static library
+libexternal_library.a instead of the shared one with the same flags as GCC/Clang:
    
+
    nvq++ my_code.cpp -Wl,-Bstatic -lexternal_library -Wl,-Bdynamic ...
+
    
+
    
+
    If the compilation fails due to undefined symbols during linking, then libexternal_library.a
+does not include the C++ standard library components it depends on. In this case, you can create a
+suitable static library that contains the external library as well as its libstdc++ dependencies
+by combining libexternal_library.a and libstdc++.a into a single flattened archive.
+For example, if the external library is built with GCC and located in /usr/lib,
+the following commands create a suitable archive using the GNU archiver:
    
+
    ar cruT libexternal_library_complete.a /usr/lib/libexternal_library.a "$(g++ -print-file-name=libstdc++.a)"
+echo -e 'create libexternal_library_complete.a\naddlib libexternal_library_complete.a\nsave\nend' | ar -M
+
    
+
    
+
    The above commands create a new static library libexternal_library_complete.a in the current directory.
+To use it, adjust the nvq++ command accordingly:
    
+
    nvq++ my_code.cpp -L. -Wl,-Bstatic -lexternal_library_complete -Wl,-Bdynamic ...
+
    
+
    
+
    
+
    Note
    
+
    If the third-party library functions you are calling from your CUDA-Q code
+consume or produce data types that explicitly depend on the C++ standard library implementation,
+a small shim is needed to properly encapsulate these dependencies, as described in
+Interfacing between binaries compiled with a different toolchains.
    
+
    
+
    
+
    
+
    Interfacing between binaries compiled with a different toolchains
    
+
    To avoid incompatibilities between different C++ implementations,
+two binaries built using a different C++ compiler should be careful when passing data types between them
+that rely on a specific C++ implementation. While primitive data types can be passed without
+issues, attempting to pass a string, for example, will result in a linking failure; a char* must
+be passed instead of a string.
    
+
    Most other data types, including templated types, can be passed as long as their alignment matches.
+While different compilers generally align data differently, it is possible to force a particular
+alignment when defining the data type or value. For example, if we define a struct
    
+
    #pragma pack(push, 4)
+template <typename ScalarType>
+struct Entry {
+  bool is_integral;
+  ScalarType value;
+};
+#pragma pack(pop)
+
    
+
    
+
    the pragma directives ensure that each item will be 4-byte aligned, regardless of the
+default setting that can differ between compilers.
    
+
    Even function pointers can usually be passed, as long as their argument and return types can be passed.
+When using templated functions and data types, the header file should only include their declaration as well
+as explicit instantiation for all valid template arguments. For example,
    
+
    template <typename CudaDataType>
+void initializeDeviceStateVector(uint32_t n_blocks,
+                                int32_t threads_per_block,
+                                void *deviceStateVector,
+                                std::size_t stateDimension) {
+  cudaInitializeDeviceStateVector<<<n_blocks, threads_per_block>>>(
+    reinterpret_cast<CudaDataType *>(deviceStateVector), stateDimension);
+}
+
+template void
+initializeDeviceStateVector<cuFloatComplex>(uint32_t n_blocks,
+                                int32_t threads_per_block,
+                                void *deviceStateVector,
+                                std::size_t stateDimension);
+
+template void
+initializeDeviceStateVector<cuDoubleComplex>(uint32_t n_blocks,
+                                int32_t threads_per_block,
+                                void *deviceStateVector,
+                                std::size_t stateDimension);
+
    
+
    
+
    The most cumbersome aspect when libraries built with different toolchains are combined into a single executable
+is exception handling. Since the handling relies on a specific ABI, an thrown exception is not necessarily
+recognized as such in a library that uses a different ABI implementation. While matching the exception type
+may not work as expected, a catch-all will reliably catch any thrown exception.
    
+
    
+
    
+
+
+           
    
+          
    
+          
+        
    
+      
    
+    
    
+  
    
+    
+
+  
+  
+
+
+
\ No newline at end of file
diff --git a/pr-2023/using/quick_start.html b/pr-2023/using/quick_start.html
index ce8a5f9c12..958c8e54f8 100644
--- a/pr-2023/using/quick_start.html
+++ b/pr-2023/using/quick_start.html
@@ -126,7 +126,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -319,8 +332,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -505,6 +524,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
diff --git a/pr-2023/using/tutorials.html b/pr-2023/using/tutorials.html
index 23d432a99a..675b7505a8 100644
--- a/pr-2023/using/tutorials.html
+++ b/pr-2023/using/tutorials.html
@@ -125,7 +125,11 @@
 
  • Quantum States
    • 
 
  • Quantum Gates
    • 
 
  • Measurements
    • 
-
  • State Visualization
    • 
+
+
+
  •    Visualization
 
    • 
 
  •    Computing Expectation Values
 
    • 
+
  • Divisive Clustering With Coresets Using CUDA-Q
+
    • 
 
 
 
  •    Backends
@@ -318,8 +331,8 @@
 
 
    • 
 
  • Building CUDA-Q
    • 
-
  • C++ Support
    • 
 
  • Python Support
    • 
+
  • C++ Support
    • 
 
  • Installation on the Host
 
    • 
 
  •    Integration
 
    • 
 
  •    Extending
      
@@ -504,6 +523,7 @@
 
    • my
      • 
 
    
 
    • 
+
  • User-Defined Custom Operations
    • 
 
 
 
@@ -587,6 +607,10 @@ 
    CUDA-Q Tutorials
   
    Water Molecule with Active Space (CPU vs. GPU)
    
     
+
+  
    
+  
    Divisive Clustering With Coresets Using CUDA-Q
    
+    
 
 
 
    

    Kernel argument serialization