From 238e96d8619849fc4bc5e0a0716ee2b987a3cd42 Mon Sep 17 00:00:00 2001 From: Nicolas Renaud Date: Thu, 4 May 2023 09:22:34 +0200 Subject: [PATCH 1/3] added apidoc --- docs/apidocs/hadamard_test.md | 161 +++++++++ docs/apidocs/matrix_decomposition.md | 330 +++++++++++++++++++ docs/apidocs/variational_linear_solver.md | 132 ++++++++ docs/apidocs/vqls.md | 286 ++++++++++++++++ docs/beginners_guide.md | 6 + docs/how_tos/04_how_to_control_options.ipynb | 44 +-- docs/technical_docs.md | 4 + vqls_prototype/hadamard_test.py | 2 +- 8 files changed, 935 insertions(+), 30 deletions(-) create mode 100644 docs/apidocs/hadamard_test.md create mode 100644 docs/apidocs/matrix_decomposition.md create mode 100644 docs/apidocs/variational_linear_solver.md create mode 100644 docs/apidocs/vqls.md diff --git a/docs/apidocs/hadamard_test.md b/docs/apidocs/hadamard_test.md new file mode 100644 index 0000000..4892203 --- /dev/null +++ b/docs/apidocs/hadamard_test.md @@ -0,0 +1,161 @@ + + + + +# module `vqls_prototype.hadamard_test` +Hadammard test. + + + +--- + + + +## class `HadammardTest` +Class to compute the Hadamard Test + + + + + +### method `__init__` + +```python +__init__( + operators: Union[QuantumCircuit, List[QuantumCircuit]], + use_barrier: Optional[bool] = False, + apply_control_to_operator: Optional[bool, List[bool]] = True, + apply_initial_state: Optional[QuantumCircuit] = None, + apply_measurement: Optional[bool] = False +) +``` + +Create the quantum circuits required to compute the hadamard test: + +.. math: +``` + + \\langle \\Psi | U | \\Psi \\rangle + +``` + + +**Args:** + + - `operators` (Union[QuantumCircuit, List[QuantumCircuit]]): quantum circuit or list of quantum circuits representing the U. + - `use_barrier` (Optional[bool], optional): introduce barriers in the description of the circuits. Defaults to False. + - `apply_control_to_operator` (Optional[bool], optional): Apply control operator to the input quantum circuits. Defaults to True. + - `apply_initial_state` (Optional[QuantumCircuit], optional): Quantum Circuit to create |Psi> from |0>. If None, assume that the qubits are alredy in Psi. + - `apply_measurement` (Optional[bool], optional): apply explicit measurement. Defaults to False. + + + + +--- + + + +### method `get_value` + +```python +get_value(estimator, parameter_sets: List) → List +``` + + + + + + +--- + + + +## class `HadammardOverlapTest` +Class to compute the Hadamard Test + + + + + +### method `__init__` + +```python +__init__( + operators: List[QuantumCircuit], + use_barrier: Optional[bool] = False, + apply_initial_state: Optional[QuantumCircuit] = None, + apply_measurement: Optional[bool] = True +) +``` + +Create the quantum circuits required to compute the hadamard test: + +.. math: +``` + + \\langle 0 | U^\dagger A_l V | 0 \\rangle \\langle V^\dagger A_m^\dagger U | 0 \\rangle + +``` + + +**Args:** + + - `operators` (List[QuantumCircuit]): List of quantum circuits representing the operators [U, A_l, A_m]. + - `use_barrier` (Optional[bool], optional): introduce barriers in the description of the circuits. Defaults to False. + - `apply_initial_state` (Optional[QuantumCircuit], optional): Quantum Circuit to create |Psi> from |0>. If None, assume that the qubits of the firsr register are alredy in Psi. + - `apply_measurement` (Optional[bool], optional): apply explicit measurement. Defaults to False. + + + +**Returns:** + + - `List[QuantumCircuit]`: List of quamtum circuits required to compute the Hadammard Test. + + + + +--- + + + +### method `compute_post_processing_coefficients` + +```python +compute_post_processing_coefficients() +``` + +Compute the coefficients for the postprocessing + + + +--- + + + +### method `get_value` + +```python +get_value(sampler, parameter_sets: List) → float +``` + +Compute and return the value of Hadmard overlap test + + + +**Args:** + + - `sampler` (Sampler): a Sampler primitive to extract the output of the circuits + - `parameter_sets` (List): the parameters of the variational circuits + + + +**Returns:** + + - `float`: value of the overlap hadammard test + + + + +--- + +_This file was automatically generated via [lazydocs](https://github.com/ml-tooling/lazydocs)._ diff --git a/docs/apidocs/matrix_decomposition.md b/docs/apidocs/matrix_decomposition.md new file mode 100644 index 0000000..ce8dcd7 --- /dev/null +++ b/docs/apidocs/matrix_decomposition.md @@ -0,0 +1,330 @@ + + + + +# module `vqls_prototype.matrix_decomposition` + + + + + + +--- + + + +## class `MatrixDecomposition` +Base class for the decomposition of a matrix in quantum circuits. + + + + + +### method `__init__` + +```python +__init__( + matrix: Optional[ndarray[Any, dtype[+ScalarType]]] = None, + circuits: Optional[QuantumCircuit, List[QuantumCircuit]] = None, + coefficients: Optional[float, complex, List[float], List[complex]] = None +) +``` + +Decompose a matrix representing quantum circuits + +Parameters +---------- matrix : npt.NDArray Array to decompose; only relevant in derived classes where `self.decompose_matrix()` has been implemented + +circuits : Union[QuantumCircuit, List[QuantumCircuit]] quantum circuits representing the matrix + +coefficients : Union[float, complex, List[float], List[complex]] (default: None) coefficients associated with the input quantum circuits; `None` is valid only for a circuit with 1 element + + +--- + +#### property circuits + +circuits of the decomposition + +--- + +#### property coefficients + +coefficients of the decomposition. + +--- + +#### property matrices + +return the unitary matrices + +--- + +#### property matrix + +matrix of the decomposition + + + +--- + + + +### method `decompose_matrix` + +```python +decompose_matrix() → Tuple[ndarray[Any, dtype[complex128]], List[ndarray[Any, dtype[complex128]]], List[QuantumCircuit]] +``` + + + + + +--- + + + +### method `recompose` + +```python +recompose() → ndarray[Any, dtype[complex128]] +``` + +Rebuilds the original matrix from the decomposed one. + +Returns +------- np.ndarray The recomposed matrix. + +See Also +-------- decompose_matrix : Decompose a generic numpy matrix into a sum of unitary matrices. + + +--- + + + +## class `SymmetricDecomposition` +A class that represents the symmetric decomposition of a matrix. For the mathematical background for the decomposition, see the following math.sx answer: https://math.stackexchange.com/a/1710390 + +Methods +------- decompose_matrix() -> Tuple[complex_arr_t, List[complex_arr_t]]: Decompose a generic numpy matrix into a sum of unitary matrices. + +See Also +-------- MatrixDecomposition : A base class for matrix decompositions. recompose : Rebuilds the original matrix from the decomposed one. + + + +### method `__init__` + +```python +__init__( + matrix: Optional[ndarray[Any, dtype[+ScalarType]]] = None, + circuits: Optional[QuantumCircuit, List[QuantumCircuit]] = None, + coefficients: Optional[float, complex, List[float], List[complex]] = None +) +``` + +Decompose a matrix representing quantum circuits + +Parameters +---------- matrix : npt.NDArray Array to decompose; only relevant in derived classes where `self.decompose_matrix()` has been implemented + +circuits : Union[QuantumCircuit, List[QuantumCircuit]] quantum circuits representing the matrix + +coefficients : Union[float, complex, List[float], List[complex]] (default: None) coefficients associated with the input quantum circuits; `None` is valid only for a circuit with 1 element + + +--- + +#### property circuits + +circuits of the decomposition + +--- + +#### property coefficients + +coefficients of the decomposition. + +--- + +#### property matrices + +return the unitary matrices + +--- + +#### property matrix + +matrix of the decomposition + + + +--- + + + +### method `auxilliary_matrix` + +```python +auxilliary_matrix( + x: Union[ndarray[Any, dtype[float64]], ndarray[Any, dtype[complex128]]] +) → ndarray[Any, dtype[complex128]] +``` + +Returns the auxiliary matrix for the decomposition of size n. + +Parameters +---------- x : np.ndarray original matrix. + +Returns +------- np.ndarray The auxiliary matrix. + +Notes +----- The auxiliary matrix is defined as : i * sqrt(I - x^2) + +--- + + + +### method `decompose_matrix` + +```python +decompose_matrix() → Tuple[ndarray[Any, dtype[complex128]], List[ndarray[Any, dtype[complex128]]], List[QuantumCircuit]] +``` + +Decompose a generic numpy matrix into a sum of unitary matrices. + +Parameters +---------- matrix : np.ndarray The matrix to be decomposed. + +Returns +------- Tuple[np.ndarray, np.ndarray] A tuple containing the list of coefficients and the numpy matrix of the decomposition. + +See Also +-------- recompose : Rebuilds the original matrix from the decomposed one. + +--- + + + +### method `recompose` + +```python +recompose() → ndarray[Any, dtype[complex128]] +``` + +Rebuilds the original matrix from the decomposed one. + +Returns +------- np.ndarray The recomposed matrix. + +See Also +-------- decompose_matrix : Decompose a generic numpy matrix into a sum of unitary matrices. + + +--- + + + +## class `PauliDecomposition` +A class that represents the Pauli decomposition of a matrix. + +Attributes +---------- basis : str The basis of Pauli gates used for the decomposition. + +Methods +------- decompose_matrix() -> Tuple[complex_arr_t, List[complex_arr_t]]: Decompose a matrix into a sum of Pauli strings. + +See Also +-------- MatrixDecomposition : A base class for matrix decompositions. + + + +### method `__init__` + +```python +__init__( + matrix: Optional[ndarray[Any, dtype[+ScalarType]]] = None, + circuits: Optional[QuantumCircuit, List[QuantumCircuit]] = None, + coefficients: Optional[float, complex, List[float], List[complex]] = None +) +``` + +Decompose a matrix representing quantum circuits + +Parameters +---------- matrix : npt.NDArray Array to decompose; only relevant in derived classes where `self.decompose_matrix()` has been implemented + +circuits : Union[QuantumCircuit, List[QuantumCircuit]] quantum circuits representing the matrix + +coefficients : Union[float, complex, List[float], List[complex]] (default: None) coefficients associated with the input quantum circuits; `None` is valid only for a circuit with 1 element + + +--- + +#### property circuits + +circuits of the decomposition + +--- + +#### property coefficients + +coefficients of the decomposition. + +--- + +#### property matrices + +return the unitary matrices + +--- + +#### property matrix + +matrix of the decomposition + + + +--- + + + +### method `decompose_matrix` + +```python +decompose_matrix() → Tuple[ndarray[Any, dtype[complex128]], List[ndarray[Any, dtype[complex128]]], List[QuantumCircuit]] +``` + +Decompose a generic numpy matrix into a sum of Pauli strings. + + + +**Returns:** + Tuple[complex_arr_t, List[complex_arr_t]]: A tuple containing the list of coefficients and the numpy matrix of the decomposition. + +--- + + + +### method `recompose` + +```python +recompose() → ndarray[Any, dtype[complex128]] +``` + +Rebuilds the original matrix from the decomposed one. + +Returns +------- np.ndarray The recomposed matrix. + +See Also +-------- decompose_matrix : Decompose a generic numpy matrix into a sum of unitary matrices. + + + + +--- + +_This file was automatically generated via [lazydocs](https://github.com/ml-tooling/lazydocs)._ diff --git a/docs/apidocs/variational_linear_solver.md b/docs/apidocs/variational_linear_solver.md new file mode 100644 index 0000000..31b7bd8 --- /dev/null +++ b/docs/apidocs/variational_linear_solver.md @@ -0,0 +1,132 @@ + + + + +# module `vqls_prototype.variational_linear_solver` +An abstract class for variational linear systems solvers. + + + +--- + + + +## class `VariationalLinearSolverResult` +A base class for linear systems results using variational methods + +The linear systems variational algorithms return an object of the type ``VariationalLinearSystemsResult`` with the information about the solution obtained. + + + +### method `__init__` + +```python +__init__() → None +``` + + + + + + +--- + +#### property cost_function_evals + +Returns number of cost optimizer evaluations + +--- + +#### property optimal_circuit + +The optimal circuits. Along with the optimal parameters, these can be used to retrieve the minimum eigenstate. + +--- + +#### property optimal_parameters + +Returns the optimal parameters in a dictionary + +--- + +#### property optimal_point + +Returns optimal point + +--- + +#### property optimal_value + +Returns optimal value + +--- + +#### property optimizer_evals + +Returns number of optimizer evaluations + +--- + +#### property optimizer_result + +Returns the optimizer result + +--- + +#### property optimizer_time + +Returns time taken for optimization + +--- + +#### property state + +return either the circuit that prepares the solution or the solution as a vector + + + + +--- + + + +## class `VariationalLinearSolver` +An abstract class for linear system solvers in Qiskit. + + + + +--- + + + +### method `solve` + +```python +solve( + matrix: Union[ndarray, QuantumCircuit], + vector: Union[ndarray, QuantumCircuit], + **kwargs +) → VariationalLinearSolverResult +``` + +Solve the system and compute the observable(s) + + + +**Args:** + + - `matrix`: The matrix specifying the system, i.e. A in Ax=b. + - `vector`: The vector specifying the right hand side of the equation in Ax=b. + + + +**Returns:** + The result of the linear system. + + + + +--- + +_This file was automatically generated via [lazydocs](https://github.com/ml-tooling/lazydocs)._ diff --git a/docs/apidocs/vqls.md b/docs/apidocs/vqls.md new file mode 100644 index 0000000..de1f185 --- /dev/null +++ b/docs/apidocs/vqls.md @@ -0,0 +1,286 @@ + + + + +# module `vqls_prototype.vqls` +Variational Quantum Linear Solver + +See https://arxiv.org/abs/1909.05820 + + + +--- + + + +## class `VQLSLog` +VQLSLog(values: List, parameters: List) + + + + +--- + + + +### method `update` + +```python +update(count, cost, parameters) +``` + + + + + + +--- + + + +## class `VQLS` +Systems of linear equations arise naturally in many real-life applications in a wide range of areas, such as in the solution of Partial Differential Equations, the calibration of financial models, fluid simulation or numerical field calculation. The problem can be defined as, given a matrix :math:`A\in\mathbb{C}^{N\times N}` and a vector :math:`\vec{b}\in\mathbb{C}^{N}`, find :math:`\vec{x}\in\mathbb{C}^{N}` satisfying :math:`A\vec{x}=\vec{b}`. + + + +**Examples:** + + + .. jupyter-execute: + + from qalcore.qiskit.vqls.vqls import VQLS, VQLSLog from qiskit.circuit.library.n_local.real_amplitudes import RealAmplitudes from qiskit.algorithms import optimizers as opt from qiskit import Aer, BasicAer import numpy as np + + from qiskit.quantum_info import Statevector import matplotlib.pyplot as plt from qiskit.primitives import Estimator, Sampler, BackendEstimator + + # create random symmetric matrix A = np.random.rand(4, 4) A = A + A.T + + # create rhight hand side b = np.random.rand(4) + + # solve using numpy classical_solution = np.linalg.solve(A, b / np.linalg.norm(b)) ref_solution = classical_solution / np.linalg.norm(classical_solution) + + # define the wave function ansatz ansatz = RealAmplitudes(2, entanglement="full", reps=3, insert_barriers=False) + + # define backend backend = BasicAer.get_backend("statevector_simulator") + + # define an estimator primitive estimator = Estimator() + + # define the logger log = VQLSLog([],[]) + + # create the solver vqls = VQLS( estimator, ansatz, opt.CG(maxiter=200), callback=log.update ) + + # solve res = vqls.solve(A, b, opt) vqls_solution = np.real(Statevector(res.state).data) + + # plot solution plt.scatter(ref_solution, vqls_solution) plt.plot([-1, 1], [-1, 1], "--") plt.show() + + # plot cost function plt.plot(log.values) plt.ylabel('Cost Function') plt.xlabel('Iterations') plt.show() + +References: + + [1] Carlos Bravo-Prieto, Ryan LaRose, M. Cerezo, Yigit Subasi, Lukasz Cincio, Patrick J. Coles Variational Quantum Linear Solver `arXiv:1909.05820 ` + + + +### method `__init__` + +```python +__init__( + estimator: BaseEstimator, + ansatz: QuantumCircuit, + optimizer: Union[Optimizer, Minimizer], + sampler: Optional[BaseSampler] = None, + initial_point: Optional[ndarray] = None, + gradient: Optional[GradientBase, Callable] = None, + max_evals_grouped: Optional[int] = 1, + callback: Optional[Callable[[int, ndarray, float, float]], NoneType] = None +) → None +``` + + + +**Args:** + + - `estimator`: an Estimator primitive to compute the expected values of the quantum circuits needed for the cost function + - `ansatz`: A parameterized circuit used as Ansatz for the wave function. + - `optimizer`: A classical optimizer. Can either be a Qiskit optimizer or a callable that takes an array as input and returns a Qiskit or SciPy optimization result. + - `sampler`: a Sampler primitive to sample the output of some quantum circuits needed to compute the cost function. This is only needed if overal Hadammard tests are used. + - `initial_point`: An optional initial point (i.e. initial parameter values) for the optimizer. If ``None`` then VQLS will look to the ansatz for a preferred point and if not will simply compute a random one. + - `gradient`: An optional gradient function or operator for optimizer. + - `max_evals_grouped`: Max number of evaluations performed simultaneously. Signals the given optimizer that more than one set of parameters can be supplied so that potentially the expectation values can be computed in parallel. Typically this is possible when a finite difference gradient is used by the optimizer such that multiple points to compute the gradient can be passed and if computed in parallel improve overall execution time. Deprecated if a gradient operator or function is given. + - `callback`: a callback that can access the intermediate data during the optimization. Three parameter values are passed to the callback as follows during each evaluation by the optimizer for its current set of parameters as it works towards the minimum. + - `These are`: the evaluation count, the cost and the optimizer parameters for the ansatz + + +--- + +#### property ansatz + +Returns the ansatz. + +--- + +#### property callback + +Returns callback + +--- + +#### property initial_point + +Returns initial point + +--- + +#### property max_evals_grouped + +Returns max_evals_grouped + +--- + +#### property num_clbits + +return the numner of classical bits + +--- + +#### property num_qubits + +return the numner of qubits + +--- + +#### property optimizer + +Returns optimizer + + + +--- + + + +### method `construct_circuit` + +```python +construct_circuit( + matrix: Union[ndarray, QuantumCircuit, List], + vector: Union[ndarray, QuantumCircuit], + options: Dict +) → List[QuantumCircuit] +``` + +Returns the a list of circuits required to compute the expectation value + + + +**Args:** + + - `matrix` (Union[np.ndarray, QuantumCircuit, List]): matrix of the linear system + - `vector` (Union[np.ndarray, QuantumCircuit]): rhs of thge linear system + - `options` (Dict): Options to compute define the quantum circuits that compute the cost function + + + +**Raises:** + + - `ValueError`: if vector and matrix have different size + - `ValueError`: if vector and matrix have different numner of qubits + - `ValueError`: the input matrix is not a numoy array nor a quantum circuit + + + +**Returns:** + + - `List[QuantumCircuit]`: Quantum Circuits required to compute the cost function + +--- + + + +### method `get_coefficient_matrix` + +```python +get_coefficient_matrix(coeffs) → ndarray +``` + +Compute all the vi* vj terms + + + +**Args:** + + - `coeffs` (np.ndarray): list of complex coefficients + +--- + + + +### method `get_cost_evaluation_function` + +```python +get_cost_evaluation_function( + hdmr_tests_norm: List, + hdmr_tests_overlap: List, + coefficient_matrix: ndarray, + options: Dict +) → Callable[[ndarray], Union[float, List[float]]] +``` + +Generate the cost function of the minimazation process + + + +**Args:** + + - `hdmr_tests_norm` (List): list of quantum circuits needed to compute the norm + - `hdmr_tests_overlap` (List): list of quantum circuits needed to compute the norm + - `coefficient_matrix` (np.ndarray): the matrix values of the c_n^* c_m coefficients + - `options` (Dict): Option to compute the cost function + + + +**Raises:** + + - `RuntimeError`: If the ansatz is not parametrizable + + + +**Returns:** + + - `Callable[[np.ndarray], Union[float, List[float]]]`: the cost function + +--- + + + +### method `solve` + +```python +solve( + matrix: Union[ndarray, QuantumCircuit, List[QuantumCircuit]], + vector: Union[ndarray, QuantumCircuit], + options: Optional[Dict] = None +) → VariationalLinearSolverResult +``` + +Solve the linear system + + + +**Args:** + + - `matrix` (Union[List, np.ndarray, QuantumCircuit]): matrix of the linear system + - `vector` (Union[np.ndarray, QuantumCircuit]): rhs of the linear system + - `options` (Union[Dict, None]): options for the calculation of the cost function + + + +**Returns:** + + - `VariationalLinearSolverResult`: Result of the optimization and solution vector of the linear system + + + + +--- + +_This file was automatically generated via [lazydocs](https://github.com/ml-tooling/lazydocs)._ diff --git a/docs/beginners_guide.md b/docs/beginners_guide.md index 53f07c2..4f0e176 100644 --- a/docs/beginners_guide.md +++ b/docs/beginners_guide.md @@ -23,6 +23,12 @@ with $|\Psi(\theta)\rangle = A|x(\theta)\rangle$. ## Installation The code does not rely on external dependencies, except qiskit itself of course. After cloning the repository pip install it. +``` +git clone https://github.com/QuantumApplicationLab/vqls-prototype +cd vqls-prototype +pip install . +``` + ## Usage The code is organized very similarly as the VQE class. Hence users may simply instantiate the VQLS class and run the otpimization diff --git a/docs/how_tos/04_how_to_control_options.ipynb b/docs/how_tos/04_how_to_control_options.ipynb index 9738067..f1a1044 100644 --- a/docs/how_tos/04_how_to_control_options.ipynb +++ b/docs/how_tos/04_how_to_control_options.ipynb @@ -126,7 +126,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAALAAAACuCAYAAACWa4e1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAALcUlEQVR4nO3df1DUd37H8ef3u6j4AxqRzKwOKqDgCQJ2REZs6g0O3kwumktzMZojxLYmf9XqTQibTmY6TtppLdFcbhwzU7wb6107odyYTGpg2mlnaBPGSR0s1XMCiRdPPBfZTjaSJhI53f1++0capxTw+LHs+l5ej//4fr/73Tfjk68fluWL4/u+j4hRbqoHEJkOBSymKWAxTQGLaQpYTFPAYpoCFtMUsJimgMU0BSymKWAxTQGLaQpYTFPAYpoCFtMUsJimgMU0BSymKWAxTQGLaQpYTFPAYpoCFtMUsJimgMU0BSymKWAxTQGLaQpYTFPAYpoCFtMUsJimgMU0BSymKWAxTQGLaQpYTMtI9QAymu/7fOnFUz3GpCxwAziOk/TnVcD3oS+9OIs7/iXVY0zK4NZtLAwkPyctIcQ0BSymKWAxTQGLaQpYTFPAYpoCFtMUsJimgMU0BSymKWAxTQGLaQpYTEv7gKPRKKFQiNWrV5OZmcny5cs5cOAAQ0ND7N27F8dxOHbsWKrHlClK67dTnj9/nocffphIJMLChQspKSnh+vXrHD16lMuXL3Pjxg0A1q9fn9pBZ9Cdb317QscFDv8VbkX5DE+TeGkbcDQaZceOHUQiERoaGjh48CBZWVkAvPLKK7z44otkZGTgOA7l5fb+4SYqEHph3H1+JIL307+D38rGyctL4lSJk7YB79+/n3A4zL59+zhy5MiIfaFQiDfeeIMLFy5QUFBAdnZ2iqaceW7t1jG3+8PDxL/fAK5L4KU/wVmSk+TJEiMt18C9vb20traSm5vLoUOHxjxmw4YNAFRUVIzYfuXKFR599FGysrJYvHgxzzzzDJ9++umMz5xs8Vd/CL+8gvvsH+L+9vpUjzNlaRlwS0sLnudRV1fHokWLxjxm/vz5wMiAv/jiC2pqagiHw7S0tHD8+HE6OzvZvn07nuclZfZkiP/sFP677+F8cwuBJx5P9TjTkpZLiI6ODgBqamrGPSYcDgMjAz5+/Dj9/f289957rFixAoC8vDw2b97M6dOneeyxx2Zu6CTxuv8T78RJKMgn8Pz3Uz3OtKVlwFevXgVg5cqVY+6PxWKcOXMGGBlwW1sbDz300N14AaqrqyksLOSdd96ZcsCVlZVEIpEJH+/PnQvNr0/pue553sh/Ef/LJliwgIyDf4ozPzNh5y4uKsa5fXtKjw0Gg5w7d25Kj03LgIeGhgC4devWmPtbW1uJRqNkZWVRUFBwd3tPTw87d+4cdXxpaSk9PT1TnicSidDf3z/xB2TOY86Un21s/vAwsZf/HG7eJPBnB3GWLU3o+a8PXIfhXyf0nBORlgEHg0EGBwfp7u6murp6xL6BgQEaGxsBKC8vH3Evg8HBQR544IFR58vJyeGjjz6a1jyT4c+dyydTfraxxV87Cpd/ibunHrdqY4LPDsuWLpvWFXiq0jLg2tpaent7aWpqYtu2bRQXFwPQ1dVFfX090WgUSN4PMCb73+NQPJbQ+0LET72F/6//hlO9Cfd7uxN23v/r0i8u6b4QiRIKhViyZAnXrl2jtLSUsrIyioqKqKqqorCwkK1bv3pt9P+/hLZ48WI+++yzUee7ceMGOTk2Xyf1zl/A+/EJyMsjEHohJXfPmUlpeQXOy8ujs7OTxsZG3n33Xfr6+igpKaG5uZnnnnuOVatWAaMDXrt27Zhr3Z6eHrZs2ZKU2RPJ//QG8b84BJ6H+7u/g//+v+OPc6xTWIBTWDDO3vtXWgYMX8XY1tY2avvNmzfp6+vDdV3WrVs3Yt/27dt56aWXCIfD5P3vj1bPnj3L5cuXOXz4cFLmTiQ/HIb//hwAr6X1nse6T3+PgMGAHd/3x/uiTEtnz55l06ZNrFmzhg8//HDEvs8//5yysjJyc3N5+eWXGR4eJhQK8eCDD/L+++/juslZcSV6DZwMujdakly8eBEYvXwAyM7OpqOjg6VLl7J7926effZZNm/eTFtbW9LilclJ2yXEeO4VMMCqVavGXHrI/WnWXVZ+U8Biy6y7An/9PglJD7PuCizpRQGLaQpYTFPAYpoCFtMUsJimgMU0BSymKWAxTQGLaQpYTJt17we2QH/se+IUsJimJYSYpoDFNAUspilgMU0Bi2kKWExTwGKaAhbTFLCYpoDFNAUspilgMU0Bi2kKWExTwGKaAhbTFLCYNutur2qBfqVo4hTwfehLL66/kTFBWkKIaQpYTFPAYpoCFtMUsJimgMU0BSymKWAxTQGLaQpYTFPAYpoCFtMUsJg2KwKORqOEQiFWr15NZmYmy5cv58CBAwwNDbF3714cx+HYsWOpHlOmIO0DPn/+PGVlZRw+fJhIJEJJSQl37tzh6NGj7Nq1i97eXgDWr1+f2kFnSPzESe5869t4//TPo/b5vk/shRe588ij+Ff6kj9cAqR1wNFolB07dhCJRGhoaGBgYIDu7m4ikQhNTU20t7fT1dWF4ziUl5enetwZ4dbXQf5K4s0/wv8kOmKf99bb+D+/iFv/NE5BfmoGnKa0Dnj//v2Ew2H27dvHkSNHyMrKursvFApRUVFBLBYjPz+f7OzsFE46c5w5c8hobIDhYeI/+OHd7f61MN7Jn+J8Yw3uzu+mbsBpStuAe3t7aW1tJTc3l0OHDo15zIYNGwCoqKi4u+3r4Kuqqpg3b15Kfk0m0Zyi1bi7n8T/j2689n/Ej8eJv3IEfJ9AYwNOIJDqEacsbQNuaWnB8zzq6upYtGjRmMfMnz8fGBnwxx9/zJtvvkkwGGTjxo1JmTUZ3LqnoLCQ+I9+jPf6X+N/dAn395/BWZ6X6tGmJW0D7ujoAKCmpmbcY8LhMDAy4C1btjAwMMDp06epra2d2SGTyMnIIKPxebh9B6+tHWddKe7jj6V6rGlL21/qvHr1KgArV64cc38sFuPMmTPAyIBdN/Ff05WVlUQikQkf78+dC82vJ3wOFi6EOXMgFsPZWImTwM+1uKgY5/btKT02GAxy7ty5KT02bQMeGhoC4NatW2Pub21tJRqNkpWVRUFBwYzOEolE6O/vn/gDMucxJ8Ez+L5P/NXXIHYHVizHe+Pvcb+5BWfZ0oSc//rAdRj+dULONRlpG3AwGGRwcJDu7m6qq6tH7BsYGKCxsRGA8vLyGf9GLRgMTup4f+5cPknwDN7bp/Ev/Bz3D/bgVm8i9kd/TPzV1wgcaUrI579s6bJpXYGnKm0Drq2tpbe3l6amJrZt20ZxcTEAXV1d1NfXE41+9ZpoMn6AMdn/HofisYTeF8Lv78c7cRJnTTHuk0/gBAK4T9fh/c1P8N4+TeD3vjPt57j0i0u6L0QihUIhlixZwrVr1ygtLaWsrIyioiKqqqooLCxk69atwMj1bzryPY/44R+A5xFofP7uS2buk0/gFBfhnTiJf30gxVNOXdoGnJeXR2dnJ4888giZmZn09fWRk5NDc3Mz7e3tXLp0CUj/gL1Tb+H39OLueRpnxYq7251AgMALz4MXJ/7qa1j9m+9pu4QAWLt2LW1tbaO237x5k76+PlzXZd26dSmYLDn8X/0K7yd/i7P2G7jffXzUfid/ZcKXEsmW1gGP54MPPsD3fYqLi1mwYMGo/adOnQKgp6dnxMf5+flUVlYmb9BpclasYE77P9zzmMBTuwg8tStJEyXerAz44sWLwPjLh507d4758Z49ezh58uSMziaTo4DHYHU9OBul7Tdx9/KbAhY7ZuUV+Ov3SYh9s/IKLOlDAYtpClhMU8BimgIW0xSwmKaAxTQFLKYpYDFNAYtpClhMc3y99eq+oz/2PXEKWEzTEkJMU8BimgIW0xSwmKaAxTQFLKYpYDFNAYtpClhMU8BimgIW0xSwmKaAxTQFLKYpYDFNAYtpClhMU8BimgIW0xSwmKaAxTQFLKYpYDFNAYtpClhM+x+QcEpuayw9XgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -139,7 +139,7 @@ "source": [ "from vqls_prototype import PauliDecomposition \n", "pauli_decomposition = PauliDecomposition(A)\n", - "pauli_decomposition.circuits[0].draw('mpl')" + "pauli_decomposition.circuits[5].draw('mpl')" ] }, { @@ -174,9 +174,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7UAAAC5CAYAAAD3cxjTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA/YUlEQVR4nO3deVxU9f4/8New78giggqi4oKogAuI2qJpZm6VV8sszdwqTW91xV/Xbmb3m0vXsptlpjdtMzWz1DTDLU3NBQXcQEUFFQQVBGTf5vP7Y2JyZFaY7Qyv5+PBQ5nzmfN5H+a8P2feZ5UJIQSIiIiIiIiIJMjO0gEQERERERERNRSLWiIiIiIiIpIsFrVEREREREQkWSxqiYiIiIiISLJY1BIREREREZFksaglIiIiIiIiyWJRS0RERERERJLFopaIiIiIiIgki0UtERERERERSZbJilqZTIYtW7bo3f6FF17AE0880ag+MzMzIZPJkJKS0uB5vPPOO4iKimpUHERERERERGQeBhe1ubm5mD17NsLCwuDi4oIWLVqgX79++Oyzz1BWVmaKGI3q4Ycfhkwmg0wmg4uLC7p06YIVK1ZYOiyD/fjjjxg8eDCaN28OLy8vxMXFISEhQef7EhIS0KdPH3h6eqJ58+YYPXo0MjMzDZ5vdnY2nnvuOfj5+cHV1RXdunXDiRMnVObz6KOPws/PT+OOhoqKCsyYMQN+fn7w8PDA6NGjcfPmTZU2dZ/VvT8bNmwwON5PP/0UoaGhcHFxQWxsLI4fP16vzZEjRzBw4EC4u7vDy8sLDz74IMrLywEA+/fvVxuLTCZDYmKiss2oUaMQFBQEd3d3REVFYd26dSp9nDt3DqNHj0ZoaChkMhk++uij+h+SEeIFgJEjRyIkJAQuLi4ICgrC888/jxs3biin1+0Euv/n6NGjamMiIiIiIrJGBhW1V65cQXR0NHbt2oWFCxciOTkZR44cQXx8PLZv3449e/aYKk6jmjp1KnJycpCamoqxY8dixowZWL9+vaXDMsjvv/+OwYMH45dffsHJkycxYMAAjBgxAsnJyRrfk5GRgVGjRmHgwIFISUlBQkIC8vLy8NRTTxk034KCAvTr1w+Ojo7YuXMnUlNT8cEHH8DHx0fZprS0FP3798eSJUs0xvPaa6/h559/xqZNm3DgwAHcuHFDJZY6a9euRU5OjvLn3iP6+sS7ceNGvP7665g/fz6SkpIQGRmJIUOG4NatW8o2R44cwWOPPYZHH30Ux48fR2JiImbOnAk7O0WK9O3bVyWGnJwcTJkyBW3btkWvXr0AAH/88Qe6d++OzZs34/Tp05g0aRImTJiA7du3K/spKytDu3btsHjxYgQGBqr9uxgjXgAYMGAAvv/+e1y4cAGbN2/G5cuX8be//a1ef3v27FFZrp49e2r8zIiIiIiIrI4wwJAhQ0Tr1q1FSUmJ2ulyuVz5fwDip59+Uv5++vRpMWDAAOHi4iJ8fX3F1KlTRXFxsXL6xIkTxahRo8Q777wj/P39haenp5g+fbqorKxUttm5c6fo16+f8Pb2Fr6+vmLYsGHi0qVLyukZGRkCgEhOTta4DA899JCYPXu2ymsdOnQQzzzzjBBCiPnz54vIyEjx9ddfizZt2ggvLy/x9NNPi7t37+odR2VlpZgxY4YIDAwUzs7OIiQkRCxcuFA5vaCgQEyePFm5nAMGDBApKSkaY9ZXly5dxIIFCzRO37Rpk3BwcBC1tbXK17Zt2yZkMpmoqqrSe75z584V/fv31ysmTZ9JYWGhcHR0FJs2bVK+lpaWJgCII0eOKF+7fz3Sx/3xxsTEiBkzZih/r62tFS1bthSLFi1SvhYbGyveeustvfuoqqoSzZs3F++++67Wdo8//riYNGmS2mlt2rQRy5Ytq/e6KeIVQoitW7eqfNb65AsRERERkbXT+0htfn4+du3ahRkzZsDd3V1tG5lMpvb10tJSDBkyBD4+PkhMTMSmTZuwZ88ezJw5U6Xd3r17kZaWhv3792P9+vX48ccfsWDBApX5vP766zhx4gT27t0LOzs7PPnkk5DL5fouhlqurq6oqqpS/n758mVs2bIF27dvx/bt23HgwAEsXrxY7zg+/vhjbNu2TXmUbN26dQgNDVW+f8yYMbh16xZ27tyJkydPokePHnjkkUdw584dAH+dFrp//369l0Eul6O4uBi+vr4a2/Ts2RN2dnZYu3YtamtrUVRUhG+++QaDBg2Co6Oj3vPdtm0bevXqhTFjxiAgIADR0dFYvXq13rECwMmTJ1FdXY1BgwYpX+vcuTNCQkJw5MgRlbYzZsyAv78/YmJisGbNGgghNM73/nirqqpw8uRJlX7s7OwwaNAgZT+3bt3CsWPHEBAQgL59+6JFixZ46KGHcOjQIY39bNu2Dfn5+Zg0aZLW5SwqKtL6mdzPVPHeuXMH69atQ9++fet91iNHjkRAQAD69++Pbdu26R0rEREREZFV0Lf6PXr0qAAgfvzxR5XX/fz8hLu7u3B3dxfx8fHK13HPEbZVq1YJHx8flSO8O3bsEHZ2diI3N1cIoThS6+vrK0pLS5VtPvvsM+Hh4aFyZPFet2/fFgDEmTNnhBCGH6mtqakR33zzjQAgPvnkEyGE4kitm5ubypHZOXPmiNjYWI3zvD+OV199VQwcOFDlyHWdgwcPCi8vL1FRUaHyevv27cXnn38uhBAiKytLdOrUSRw7dkxjn/dbsmSJ8PHxETdv3tTabv/+/SIgIEDY29sLACIuLk4UFBQYNF9nZ2fh7Ows3nzzTZGUlCQ+//xz4eLiIr788st679f0maxbt044OTnVa9+7d2+V9ejdd98Vhw4dEklJSWLx4sXC2dlZ/Pe//9U73uzsbAFA/PHHHyrt5syZI2JiYoQQQhw5ckQAEL6+vmLNmjUiKSlJ/P3vfxdOTk7i4sWLavsZOnSoGDp0qMY4hBBi48aNwsnJSZw9e1btdHVHao0db3x8vHBzcxMARJ8+fUReXp5y2u3bt8UHH3wgjh49Ko4fPy7mzp0rZDKZ2Lp1q9blIiIiIiKyJo2++/Hx48eRkpKCiIgIVFZWqm2TlpaGyMhIlSO8/fr1g1wux4ULF5SvRUZGws3NTfl7XFwcSkpKcP36dQBAeno6xo0bh3bt2sHLy0t59PPatWsGxbxixQp4eHjA1dUVU6dOxWuvvYaXX35ZOT00NBSenp7K34OCglSuZ9QVxwsvvICUlBR06tQJs2bNwq5du5TvPXXqFEpKSpQ3R6r7ycjIwOXLlwEArVq1wvnz5xETE6PX8nz33XdYsGABvv/+ewQEBGhsl5ubi6lTp2LixIlITEzEgQMH4OTkhL/97W9qj35qmq9cLkePHj2wcOFCREdHY9q0aZg6dSpWrlypV7yG+Ne//oV+/fohOjoac+fORXx8PP7zn/+obavv3+F+dUfYp0+fjkmTJiE6OhrLli1Dp06dsGbNmnrts7KykJCQgMmTJ2uc52+//YZJkyZh9erViIiI0DsWY8c7Z84cJCcnY9euXbC3t8eECROUn7W/vz9ef/11xMbGonfv3li8eDGee+45jX9fIiIiIiJr5KBvw7CwMMhkMpUiFADatWsHQHEKr6mNGDECbdq0werVq9GyZUvI5XJ07dpV5dRhfYwfPx7z5s2Dq6srgoKCVG6uA6De6ZkymUzlFGddcfTo0QMZGRnYuXMn9uzZg7Fjx2LQoEH44YcfUFJSgqCgILWnFjdr1syg5QCADRs2YMqUKdi0aZPKKavqfPrpp/D29sb777+vfO3bb79FcHAwjh07hj59+ug136CgIHTp0kXltfDwcGzevFnvuAMDA1FVVYXCwkKV5b5586bGGygBQGxsLP7973+jsrISzs7OOuP19/eHvb19vbsq39tPUFAQAKhdJnU7TNauXQs/Pz+MHDlSbYwHDhzAiBEjsGzZMkyYMEHjsqhj7Hj9/f3h7++Pjh07Ijw8HMHBwTh69Cji4uLU9h8bG4vdu3cbFDMRERERkSXpfaTWz88PgwcPxieffILS0lKDOgkPD8epU6dU3nf48GHY2dmhU6dOytdOnTql8kiSo0ePwsPDA8HBwcjPz8eFCxfw1ltv4ZFHHkF4eDgKCgoMiqOOt7c3wsLC0KpVq3oFrS76xuHl5YWnn34aq1evxsaNG7F582bcuXMHPXr0QG5uLhwcHBAWFqby4+/vb1As69evx6RJk7B+/XoMGzZMZ/uysrJ6y2tvbw8AKkW7rvn269ev3s6Nixcvok2bNnrH3rNnTzg6OmLv3r3K1y5cuIBr165pLLgAICUlBT4+PioFrbZ4nZyc0LNnT5V+5HI59u7dq+wnNDQULVu21GuZhBBYu3YtJkyYoPY65P3792PYsGFYsmQJpk2bpsdfQpWx471X3Wes6YwKQPH3rSuaiYiIiIgkwZBzlS9duiRatGghOnfuLDZs2CBSU1PF+fPnxTfffCNatGghXn/9dWVb3HNNbWlpqQgKChKjR48WZ86cEfv27RPt2rUTEydOVLafOHGi8PDwEOPGjRPnzp0TO3bsEC1atBD/7//9PyGE4g6wfn5+4rnnnhPp6eli7969onfv3ir9NPTux/equ/vxvZYtWybatGmjdxwffPCB+O6770RaWpq4cOGCmDx5sggMDBS1tbVCLpeL/v37i8jISJGQkCAyMjLE4cOHxT//+U+RmJgohNDvmtp169YJBwcH8emnn4qcnBzlT2FhobLN8uXLxcCBA5W/7927V8hkMrFgwQJx8eJFcfLkSTFkyBDRpk0bUVZWpvd8jx8/LhwcHMR7770n0tPTxbp164Sbm5v49ttvlW3y8/NFcnKy2LFjhwAgNmzYIJKTk0VOTo6yzUsvvSRCQkLEvn37xIkTJ0RcXJyIi4tTTt+2bZtYvXq1OHPmjEhPTxcrVqwQbm5u4u233zbo77Bhwwbh7OwsvvzyS5GamiqmTZsmmjVrpryeu+4z9vLyEps2bRLp6enirbfeEi4uLip3tRZCiD179ggAIi0trd5nsm/fPuHm5ibefPNNlVjy8/OVbSorK0VycrJITk4WQUFB4h//+IdITk4W6enpRo336NGjYvny5SI5OVlkZmaKvXv3ir59+4r27dsrr+f+8ssvletpWlqaeO+994SdnZ1Ys2ZNvWUjIiIiIrJWBhW1Qghx48YNMXPmTNG2bVvh6OgoPDw8RExMjPjPf/6jcpMnNPCRPm+//bbw8/MTHh4eYurUqSo3VNq9e7cIDw8Xzs7Oonv37mL//v1mL2r1iWPVqlUiKipKuLu7Cy8vL/HII4+IpKQk5fvv3r0rXn31VdGyZUvh6OgogoODxfjx48W1a9dUluO3337TuhwA6v3cu6Ng/vz5KnELIcT69etFdHS0cHd3F82bNxcjR45UKdD0ma8QQvz888+ia9euwtnZWXTu3FmsWrVKZfratWvVzmf+/PnKNuXl5eKVV14RPj4+ws3NTTz55JMqRe/OnTtFVFSU8PDwEO7u7iIyMlKsXLlS5cZh+sa7fPlyERISIpycnERMTIw4evRovb/pokWLROvWrYWbm5uIi4sTBw8erNdm3Lhxom/fvvVeF0KxDquL5aGHHlK2qftstbUxRrx1+ebr6yucnZ1FaGioeOmll0RWVpayzZdffinCw8OFm5ub8PLyEjExMSqPWCIiIiIikgKZEFqej0JERERERERkxRp992MiIiIiIiIiS2FRS0RERERERJLFopaIiIiIiIgki0UtERERERERSRaLWiIiIiIiIpIsFrVEREREREQkWSxqiYiIiIiISLJY1BIREREREZFksaglIiIiIiIiyWJRS0RERERERJLFopaIiIiIiIgki0UtERERERERSRaLWiIiIiIiIpIsFrVEREREREQkWSxqiYiIiIiISLJY1BIREREREZFksaglIiIiIiIiyWJRS0RERERERJLFopaIiIiIiIgki0UtERERERERSRaLWiIiIiIiIpIsFrVEREREREQkWSxqiYiIiIiISLJY1BIREREREZFksaglIiIiIiIiyWJRS0RERERERJLFopaIiIiIiIgky8HSAZB1EkIA1bWWDoP05WgPmUxm6SjIhnAMkCCOAzaL+WjlmHtGxfXdhpgxN1jUknrVtaiZt8nSUZCeHN4bAzgxncmIOAZIDscBG8Z8tGrMPSPj+m4zzJkbPP2YiIiIiIiIJItFLREREREREUkWi1oiIiIiIiKSLBa1REREREREJFksaomIiIiIiEiyWNQSERERERGRZLGoJSIiIiIiIsliUUs25euzB+C09Fl8ffaA2umZRbfhtPRZTN650syREZE5cAwgsizmIBHzwBJY1BIREREREZFksaglIiIiIiIiyWJRS0RERERERJLFopaIiIiIiIgki0UtERERERERSZbNF7V5eXmIj49HWFgYXFxcEBwcjNmzZ6O0tBSTJ0+GTCbDJ598YukwicjEyiqBCznA6euKf8urLB0REZmTEEB2AXAuCzibBWTdUbxG1JTcvgukZityIDMPkDMHyEY4WDoAU0pJScHQoUORm5sLd3d3dOnSBTdu3MDHH3+My5cv486dOwCAqKgoywZKZie75/+v7l6DHVeSUFRZDk8nF4zuGItFDz0LJ3ubTo8m40YB8PsF4GQmUF371+tO9kDPtsCDnYCgZpaKjiyFY0DTUVMLJGYAhy4qitp7tfQB+nUAYtoBjvaWia+pYg6aj1wAp64pcuDyLdVpfh5A3zAgrgPg5mSZ+Joy5oHx2OyR2ry8PIwYMQK5ubl44403kJOTg6SkJOTm5mLJkiXYsWMHEhMTIZPJ0L17d0uHS0bi4qAYkcuq1R+GK62uBAC4Ovw1cr8c/SjOTFqK/Flf4MSERTh9+xoWH91i8ljJ9E5kAB/8Chy9rFrQAkBVLXDkErB0J5B81TLxkfFxDKB7lVUBn+0DNh6rX9ACip1em44Dn+1VnM1BjccctC41tcC3h4GvDtUvaAEgvwT4OQX4KEHxfzIO5oH52WxRO2vWLGRlZWHmzJlYunQpPD09ldPi4+MRGRmJmpoahIaGwsvLy4KRkjG19W4OADh/J1vt9PP5itdD/2wHAF38W8PdyQUAIADYyWS4VJhr2kDJ5M5mAev+AGrl2tvVyoFvDgNpN8wTF5kWxwCqU1MLrPld/Rf5+125DfzvQP2dX2Q45qD1EEKxQydJjx23t+4CK/cBJRWmj6spYB6Yn00WtWlpadi4cSP8/f2xaNEitW169uwJAIiMjFR5PSMjAyNHjoSnpyd8fHwwYcIE5OfnmzxmMo7oFm0R7OmH788fwY0S1d3yVbU1+Cx5F2SQYXhYT5Vp7x/bBp//TkKrFS/h9O2rmNVjqDnDJiOrlSuOvuh7qZBcAD8kAnIdBTBZP44BVOdEJnDppv7tr9wGEq+YLJwmgzloPa7cUpx6r6/bxcC+VNPF05QwD8zPJk/SXr9+PeRyOcaPHw8PDw+1bVxdXQGoFrXFxcUYMGAAfH19sX79epSXlyM+Ph7Dhw/H4cOHYWdnk/sAbIqDnT2WD3oRY7Z+iJ5fzcULXQegfbMA3CwrwqbzR5Gan4W5saPQybelyvviY0ciPnYk0vKzsT7tMAI9mllmAcgozmYBReWGvSe/BDifA3RpZZqYyDw4BhCgOEJ16KLh7zuUDsSFATKZ7rakHnPQehxKN/w9x64AQyN5jXljMQ/MzyaL2n379gEABgwYoLFNVlYWANWidtWqVcjOzsbvv/+OkJAQAEDr1q3Rt29fbNu2DU888YTpgiajebx9NA6MewdLE3/Gt+d+R35FCdwdnREVEIp1cbMwpnMfje8N92uF7s1DMOmXz7D76bfMGDUZkyF7pu91/AqLWlvAMYByixR3NzbUjQLgRiHQysfoITUpzEHLq6hW3O3fUKWVirsjR4YYP6amhnlgXjZZ1F69qrh4oE2bNmqn19TU4PDhwwBUi9rt27ejf//+yoIWAOLi4tCuXTv8/PPPDS5qe/XqhdxcaZ0T72rviNSxCy0dRoP1CmqPDSP/3qD3VstrkV6QY9yATKxjhw4or622dBhW45FZO+HTqpvB79t78CTeGjfKBBFJD8cAaY0BAMeBewV2GoD+L37ToPc+MWYics7vNXJEjSPFfGxKOWiNuefuF4qh8Yca9N6/x7+D9EP/M3JE+pPi+q5JU8oDdQzNjcDAQJw4caJBfdlkUVtaWgoAKC9Xf/7hxo0bkZeXB09PT7Rt21b5empqKsaMGVOvfUREBFJTG36RQW5uLrKz1V8obq3cHJ0tHYJZFFWWYWt6IkaG9YK3sxvO5F3HoiNbMDhUWnfEvpGTg7Jq3rqzTnV1w75cVFZWSi5XTYVjgLTGAIDjwL0c/G43+L15+XlWNw7Ycj7aQg5aY+5517g0+L2FhYUWzQFbXt81sYU8UMecuWGTRW1gYCAKCgqQlJSEuLg4lWk5OTmYM2cOAKB79+6Q3XPhTEFBAZo1a1Zvfr6+vrhw4UKj4pEaV3tHS4dgFjIA36Uewpz936KqtgYBbl54okMM3u472tKhGaRlUJDV7SW2pOpSPW53qkZteR5ateL5xwDHAKmNAQDHgXu5OSgeoyGEUNnOa1PX1s2+yurGAVvOR1vIQWvMPQcne8hrqmDnYPjDZ51QZtEcsOX1XRNbyAN1DM2NxtRMNlnUDho0CGlpaViyZAkGDx6Mjh07AgASExPx/PPPIy8vDwAQFRVllngaehjdkkRVDWrmbbJ0GCbn5eyGX8fOs3QYjXYxPR0yJ5tM5wY5fV3xKA9D/d/fRyL8/ZHGD0iCOAZID8cBVR/+ClzL1/+OTzKZDK19gLOJu63uRlG2nI+2kIPWmntfH9LvcT73cncGDu1YZdEbRdny+q6JLeSBOubMDZu8nW98fDz8/Pxw/fp1REREoFu3bujQoQNiYmLQrl07DBw4EED9x/n4+PigsLCw3vzu3LkDX19fc4ROREYQ0Qpo5mbYe/w8gE5BpomHiMyvX4cGvKcj73xMtqN/R8Pf06c973xM0mSTRW3r1q1x8OBBDBs2DC4uLsjMzISvry8+//xz7NixAxcvKu7zf39RGx4ervba2dTUVISHh5sldiJqPHs7YEyM4nQefdjJgLExin+JyDb0DAU6GnAmW1gLoHdb3e2IpKJtcyC2vf7tA7yAgV1MFw+RKdlkUQsoCtTt27ejuLgYxcXFOHbsGKZNm4bS0lJkZmbCzs4OXbt2VXnP8OHDcejQIeXjfgDg2LFjuHz5MkaMGGHuRSCiRohoBTzfT1HgauNgD7zwAI/SEtkaB3vgxQf1K2zDWijaOvAIFdkQ2Z87bPXZWRPoDbw8UHH6MZEUWd8FACZ27tw5CCHQsWNHuLmpnp84bdo0LF++HKNGjcKCBQtQUVGB+Ph4xMTEYNQoPuaDSGp6hAItfYDfLwAnMoCqmr+mOTsAvdsBD3QEWnhbLEQiMiEXR2Daw4rrCg9dBK7lq04P9lWcotkzlAUt2SZ7O+DZOKBbMHD4InDhvidMNvdUnHbfp70iX4ikqskVtWfOnAFQ/9RjAPDy8sK+ffswe/ZsPPPMM3BwcMDw4cOxbNky2NnZ7EFtIpsW6K3YUz0yGvj3FqC0CnB3Av71BDfgRE2Bgz0Q007xk1sEfLwLKKsCPJyBN4ZaOjoi05PJgO7Bip+8YsVN1Opy4M0RvPSGbAOL2vu0b98e27dvN2dIRGQGLo5/HYlxsGdBS9QUBXr/dRMcXZcmENkif0/VHGBBS7aCRS0Z7LW9X2H75ZO4ejcPxycsRFRAqNp2lTXViN//LXZnnoazgxO6Nw/BV8NmIL+8GEO+X6hsV1ZTiYzCW8h+ZSV8XT009ltRU4Xx25cjLT8brg5OCHDzwvJBLyLMR/0FUwkZpzD/0Peoqq2Bm6MzPh08GZEBbRq17HXSC3IweedK5JUXw9vJDf8b+hIi/Furbavt76VpPoYuK5G56coBQ9bhr87sx9SEVdg06jWM6tAbgObxwxw2XziGnVeSUVBZarEc3HzhGH67dhZLBzzPsYA00ndbpK1dh1Wz4GTvCNc/n2caHzsSYzvH6cxhfb8LSJE1jAGknqW+gwLA45sWIbe0EHYyO3g6ueDDgRMR3UJ9//rkprptnzHY8vZZmyZX1O7bt8/SIUjeUx1j8EbMcAxYv0Bru3kHN0Amk+Hc5A8hk8mQW1oIAPBz9cSJiYuU7T5M3I7fr6fpHEwAYEr3gXisbRRkMhlWJCXgpYTV2PPMv+q1K6gowcQdn2LvM28jwr81DmWdx8QdnyJl0vuGLawGM3Z9gSndB2JC14ew+cIxTNm5Ekee/z+1bbX9vbTNR99lJbIEfXJAn3U4s+g2vjjzG2KDwlRe1zR+mMPWS4n4W6c+cLSzt1gObr2UiOe6PACAYwFppu+2SFe7dSNeVVscaFv39P0uIEXWMAaQepb8DvrdiFlo5uIOANiSnogpv67EyYmL1bbVlXOatn3GYMvbZ2148g0Z7IHgcLT29NPaprSqAmvP7Me7/cdC9udD/wLdm6ltu/bMfkzq9rDOfl0cnDC0XbRyfrEtO+Dq3dtq214pvAVfVw/lnqn+rTvjenE+km9m6OxHl1ulRTh5MwPPdukPQDHAZhXn41JBrtr2mv5e2uZjyLISmZs+OaDPOiwXcryUsAofDZwIZ/u/zgc3ZPwwVGFFKdqunInAT6ah11dvotuaf8Bj2QRMT1gFAKiurcGR7IsY2jbKpDmoLY66GAaERHAsII303RYZus2qo2vd0+e7QEPpylNTzttcYwA1jKW+gwJQFrQAcLeyDDINDw7UlXOatn3GIOXtc2M1uSO1ZB6Xi27B18Udi49txb6rZ+Hq4IR/9R2NgW1UH6N0JPsiCitKMax9D4P7WJ70K0aE9VQ7LcwnEHfKS3Ak+yLiWnXEz5dOoriqHJlFtxHdonEPIswqzkegezM42CkuSpHJZAj28sP14nyDTksyZD7alpXI3BqSA+rW4Y9O/IK4Vp3QI7Cdyuv6jh8N0czFHU+H94WnkwvmxT2FXRmnsOTYVnw+ZBoAYP/1VPRp2RGO9qqbR2PnoLY4dmeeVhuDKeIg6dI3D/Vp9+Ivn0EA6B3YHu89+Ayau3nV68+c656uPDXlvM01BpDpmPI76KRfVuDA9VQAwNan4tW20ZVzmrZ9xiDl7XNjsaglk6iV1+Lq3TyE+7XCwgfHIflmJh7/YSFSXvgPWrj/9fyUtWf2Y3zEA8rk09fio1twuSAXK8bOUzvd29kNG0bOxlsHN6CkugJ9gjog3K+VXv08sO5tXCpUvwf7+POL1L5uSrqWlcjaqVuHz96+jp8uHse+Z96u117f8UMdXfkb7OWH07euYkaPIQCApJsZKqddbks/gVEdeumMv7ExANAYh7oYGhIHkT72PvM2Qrz8UV1bg7cPbcLknZ9h2+i5Km2Mue41Nj+MMX9TjwFkWab8Drr28VcAAF+f/R3zfl9fL1d00bbt00Xf3DGEObfPpsailkwi2NMPdjIZng1XnP4Q3SIUoV4BOJt3DS3cuwEASqoq8MOFo/jjuX8bNO8PE7djS3oifh3zT7g5an5K+MMhEXg4JAKA4qL24M9eRrhfK53zPzj+Xa3Tne0dkFtaiBp5LRzs7CGEwPW7+Qg28DSs1p5+Ouej77ISmZM+624dTevw4ezzuHo3D12+eB0AkFtahLRdXyC3tBCjO8bqHD800ZW/AHDq1lXll9ikmxkY3l6xh1oIgd2Zp7HooWd1xt/YGDTFoS6GhsZBtk3fPNTVLsTLHwDgaO+AWT0fQ8QXb6i839jrXmPyw1jzN/UYQJZlyu+gdSZ0fRAz93yB/PJi+Ll6qkzTlnN7r57RuO2bHjVYa5/6rNvWvH02NV5TSybh7+aFgSFdsSvzFAAgo/AWMu/eQmffv4rKTReOoHtACDrfV2hO+mUFtqQnqp3vRyd2YOP5P7BzzJsq1zaok1NSoPz/e0d/wsMhEcpTL7T1oUuAuzeiA0LxXeohAMCPF4+jlaevwXdE1DUfQ5aVyJz0zQFt6/D0qMG49vIKpE/7GOnTPkZsUBhWPDoZ06MG6xw/GpO/2cV3IJMBrTx9AQBnb19Dt+bBAIDE3Mvo7NcKHk4uOuNvTAza4rg/Bl1xUNOlbx5qa1daVYHCilJl243n/0DUPXdzbei6Z6r8MMb8jTUGkPUyxXfQwopS3Ljne+XW9ET4uXjC16X+Daa05Zy2bZ+2/vVl6e2zJfFILRnslV3/w84rKcgtLcTwHxbD08kVaVOWAQCmJ6zC8PY9MSKsJz4Z/CKmJ6zGP3/fADuZDJ8OnqLciACK0z4mdxtQb/4nczMws8dj9V7PKs5H/P51aOcdgMEb3wOgOGp6+M+9bPf2DQALDv+AQ9nnUSuXI7ZlB6y651ocTX3o69NHJ2PKzpVYfGwrvJxcsfqx6SrT741F299L03x0LSuRpWnLgekJq9C/dedGrcPaxo/G5G/KrUyVUw29nd2xMmU3Ph8yDVvSEzEyTHHaoa4cbOwYoikOP1dPZQz6xEFNm648rNsOaWp3s6wIT2/7CLVyOQSAtt4BWDP0ZQC61z1t2zZT5Ufdda/WMAaQZVjqO2hRZRnG/fxflNdUw04mQ3NXT/z01D+UN0u6/zuoru+JmjQ2d3T1bertsyXJhBDC0kGQ9RFVNaiZt8ns/d4uu4sJOz7BzjH/lHQf5ubw3hjInLiPSpf5PwJF5YC3K7DgKUtHY90sNQboYsr8jVw7B7vHvoUAHdcFWUMM6nAc0I8UxwFrzUd1TL2Ntcb8k1ruWXsO2PJ3UGvu3xTMmRssakktKW1ASXobVEux9g25NeEYID0cB/QjxXGA+WjdpJZ71p4DXN9thzlzg9fUEhERERERkWSxqCUiIiIiIiLJYlFLREREREREkiWdCwDIvBzt4fDeGEtHQfpy1P/B4UR64RggPRwHbBfz0box94yL67vtMGNusKgltWQyGSChmx4QkXFxDCCyHsxHakq4vlND8PRjIiIiIiIikiwWtURERERERCRZLGqJiIiIiIhIsljUEhERERERkWSxqCUiIiIiIiLJYlFLREREREREksWiloiIiIiIiCSLRS0RERERERFJFotaIiIiIiIikiwWtURERERERCRZLGqJiIiIiIhIsljUEhERERERkWSxqCUiIiIiIiLJYlFLREREREREksWiloiIiIiIiCSLRS0RERERERFJFotaIiIiIiIikiwHSwdA5iGEAKprLR0GWRNHe8hkMktHQWbGsYAAMP8livlrZZhHZsccsDJWlAMsapuK6lrUzNtk6SjIiji8NwZw4hDQ5HAsIDD/JYv5a1WYRxbAHLAq1pQDPP2YiIiIiIiIJItFLREREREREUkWi1oiIiIiIiKSLBa1REREREREJFksaomIiIiIiEiyrON2VUREJiAEkFcCXM8HsgqAsirF62VVwM/JQGtfINgX8PMArOSO9ERkZJXVQHYBcP0OkFukOg7sP68YA1r7AM6Olo2TyFSqa4GcQsW28Eahag7sOfdnDvgC7s6WjJKocVjUEpHNKakAjl8BDqcD+SX1p1fXAntT//rd3xPo1wGIaceNOpEtEAK4cgs4lA6cugbIRf021bXAlpOK/9vJgO7BQP+OQPsA7uQi25BdABy6CJzMAKrUPNq1uhbYnvLX752CgP4dgIhWgB3P5SSJYVFLRDajphZIOAP8lgbUyPV/X14xsDUJ+OUUMLALMDgCcLA3XZxEZDrX7wAbjwFZd/R/j1wAKdcUP618gKdjgRA/08VIZEr5JcD3x4ALuYa970KO4sfXHRgTA4S3NE18RKbA/TBkU74+ewBOS5/F12cPqJ2eWXQbTkufxeSdK80cGZnatXxg6U5g9znDCtp7Vf9ZFH/4q2FfiMl6cAxoumpqFTumljUyf7MLgI8SgB0pinmSYZiDliOE4sjskh2GF7T3ulMKfP4bsP4oUF5lvPiaEuaB+bGoJSLJO30d+O8uxfVyxnCjUDG/c9nGmR8RmVZlDbB6P7DrrPpTjQ0lF4odZJ//prgml8jayeXAhmPAD4lAVY1x5nnsMvDxLqCo3DjzIzIlFrVEJGlnrgNfHgRqG3h0VpPqWuCLA0AqC1siq1ZdC/xvf+OOTGmSfhNYtd94RQKRKcgFsP6Yogg1tpwi4NM9QHGF8edNZEwsaolIsm4UAF8dMs6RGXXkAlh7ELhppCPARGR8m44rik9TuXxLcX0ikbXaew5IvGK6+d+6C6w5oDgaTGSteKMoIpKkWjnw3VHDrp99/THAyxW4W664blYf1bWKfmYP5t0giazN2SzFnc4N0ZBx4EQmEBkCdAs2OEQik7pRAPx6xrD3NCQHMvIUj8Aa2MXwGInMoUl8RcvLy0N8fDzCwsLg4uKC4OBgzJ49G6WlpZg8eTJkMhk++eQTS4dJRAbYm2r4zWC8XIFmbop/DXH1z405EVmPsirg++OGv6+h48D3x4HSSsP7IzKVup27hl5+09Ac+OUUcPOuYe8hMhebP1KbkpKCoUOHIjc3F+7u7ujSpQtu3LiBjz/+GJcvX8adO4pvxVFRUZYNlIj0VlkD7EvV3c6Y9qYCD3QCHPmoHyKrcPSS4kiTuRRXAEcuAYMizNcnkTbnss17p/4aOfBbKvBMH/P1SaQvmy5q8/LyMGLECOTm5uKNN97A/Pnz4enpCQB4//33MXfuXDg4OEAmk6F79+4WjpbMSXbP/1/dvQY7riShqLIcnk4uGN0xFoseehZO9jadHpKWlAlUmPmOpKWVwKlrQK+25u2XTINjgLTJBXA43fz9Hk4HBobzUgRjYA423uGL5u/zZCYwMhpwczZ/37aIeWA8Nj0sz5o1C1lZWZg5cyaWLl2qLGgBID4+HpGRkaipqUFoaCi8vLwsGCkZi4uDEwCgrFr9g9VKqxXnjrn+2Q4AXo5+FGcmLUX+rC9wYsIinL59DYuPbjF5rNRwf1jgyyxgmS8QZBiOAU3DxVwgv8T8/RaUAudzzN+vlDAHzSOv2DR3/NaluhZIzDB/v1LDPDA/my1q09LSsHHjRvj7+2PRokVq2/Ts2RMAEBkZqXytrgiOiYmBs7MzZDKZ2veSdWrr3RwAcP6O+uewnM9XvB76ZzsA6OLfGu5OLgAAAcBOJsOlQgtsKUgvFdXAdTOebnWvq/l8tIe14xjQNKRb8OO5ZMI7LdsC5qB5XLplub4vW7BvqWAemJ/NFrXr16+HXC7H+PHj4eHhobaNq6viCvl7i9pLly5h8+bNCAwMRO/evc0SKxlPdIu2CPb0w/fnj+BGSYHKtKraGnyWvAsyyDA8rKfKtPePbYPPfyeh1YqXcPr2VczqMdScYZMBzHn90P3kArhRaLn+STeOAU2DJccBS+1UkwrmoHlk5Vuu7+sW7FsqmAfmZ7Mnae/btw8AMGDAAI1tsrKyAKgWtQ8++CBychTnFr3zzjs4fPiwCaMkY3Ows8fyQS9izNYP0fOruXih6wC0bxaAm2VF2HT+KFLzszA3dhQ6+bZUeV987EjEx45EWn421qcdRqBHM8ssAOlkyS+zdf2H+ls2BtKMY0DTkFWgu42psKjVjjloHtctmAMFZUBJBeDhYrkYrB3zwPxkQghh6SBMITg4GFlZWUhOTlZ7Z+OamhoEBQUhLy8Ply9fRrt27eq1eeedd7BgwQI09k/Uq1cv5OZa9vQBV3tHpI5daNEYzOlEzmUsTfwZh7MuIL+iBO6OzogKCMW0yEEY01n7bft+uHAUn6fswe6n3zJTtJbR5ft/orzWzHdbMoKuQ+ai88BX1U6re/aeJl4uihu8yOXA3Qrt/Wh6ft+5XUuRtvcj/QO2Mk1lLOAYoJ1U87/O35ZkaZxmrHFA2zM8N7/ZBkJeq2e0xiOl/G0KOWjJPHpsziF4+IeqnWaObWHC0odQfPuy/gEbiZRyALD9PDB2DgQGBuLEiRMNeq/NHqktLS0FAJSXq7/f/8aNG5GXlwdPT0+0bWva25nm5uYiO1v9OfXm4ubYtG5T1yuoPTaM/HuD3lstr0V6ge3fCeRGTg7KqqX30MW25Zq3wHXP3tPFzk6/duqUllVYPJ8bo6mMBRwDtJNq/gOAnY47gZpjHMi9eRs1VWZ8ntCfpJS/TSEHLZlHcmi+54s5ciAvvwB5FtgWSikHANvPA2valthsURsYGIiCggIkJSUhLi5OZVpOTg7mzJkDAOjevbvJbwYVGBho0vnrw9Xe0dIhWKWiyjJsTU/EyLBe8HZ2w5m861h0ZAsGh9r+I55aBgVJ8kiNm4uTxmm6nllp6N5ptf27OqFVq1Y6orReHAtUNdUxQKr5X0fI5ZBpeK6OscYBbfNpEeAPCLkekRqXLeavlHPQknkkE5rPFDDHttDP1xvOcvNvC20xBwDp5oGxc6AxNZPNFrWDBg1CWloalixZgsGDB6Njx44AgMTERDz//PPIy8sDALWnJhtbQw+jG5OoqkHNvE2WDsPqyAB8l3oIc/Z/i6raGgS4eeGJDjF4u+9oS4dmchfT0yFzkt4QcOQSsPGY+mmaThWs886Tir3SdyuAd35qWP8L34lHzNfxDXuzFeBYoKqpjgFSzf86C7YoHq+jjqnHgWZuQNb1a4a/0QhsMX+lnIOWzKMVexWPtlLH1DkgkwGnThyEswUW3RZzAJBuHljTtsQ6ojCB+Ph4fPfdd7h+/ToiIiLQuXNnVFRU4NKlSxg6dChCQ0ORkJCgcpMoanq8nN3w69h5lg6DDNDa17L9B1u4fzIujgHSFOyruag1NUuPQbaGOdgwwb6ai1pTa+EFixS0tox50Hg2+0if1q1b4+DBgxg2bBhcXFyQmZkJX19ffP7559ixYwcuXrwIACxqiSQmyBuwt9DI5WSv2JgTkWVZcucSd2yRNWAOEKmy6f0s4eHh2L59e73XS0pKkJmZCTs7O3Tt2tUCkRFRQznYA52DgHMWuFdTeEvFdUhEZFkRrYAdpyzXN5GldQgEHO2BavPfhJs5QFbJpotaTc6dOwchBDp27Ag3t/q3ffvhhx8AAKmpqSq/h4aGolevXuYLlIjU6tfBMkVt/47m75OI6mvpA7RrDly5bd5+2/jz9GOyDu7OQHQb4PgV8/br5Qp0CzZvn0T6aJJF7ZkzZwBoPvV4zJgxan+fOHEivvzyS5PGRkS6dW4J+HkA+SXm6zPACwhrYb7+iEi7fh3NX9T262De/oi06d/R/EVtn/aWuwSISJsmuVrqKmqFEGp/WNASWQc7GTCqh3n7fKKH4o6PRGQdokOANn7m6y/YF+gZar7+iHQJ8VMcrTUXb1fg4XDz9UdkCB6pJQDAa3u/wvbLJ3H1bh6OT1iIqIBQte0qa6oRv/9b7M48DWcHJ3RvHoKvhs1QafPVmf2YmrAKm0a9hlEdehstxvSCHEzeuRJ55cXwdnLD/4a+hAj/1hrbq4tj55VkzD+0CXIhUCOvxeu9h2NC1wf1XjZzxZ+QcQrzD32PqtoauDk649PBkxEZoNhyPb5pEXJLC2Ens4Onkws+HDgR0S1CdU6zNd2DgR5tgKSrpu8rph3QpYlcQ6RrPc0vL8aQ7xcqfy+rqURG4S1kv7ISvq4eGtfBipoqjN++HGn52XB1cEKAmxeWD3oRYT76PZNO3/zR1k5bjndYNQtO9o5wdVA8Bzk+diTGdo7T+T5jMNb4a+o4rY2dHTAuDlj6C1Bj4kfG2tsBz8ZZ7xEqQ/JLW45o2/aYM8Y66rbj2nLVWP1LKZdG9wLSbwIlOp43awxPxwJumh8Vb1HG+nwbsn4Zum6bav0yNA5t256G5pklNcmidt++fZYOweo81TEGb8QMx4D1C7S2m3dwA2QyGc5N/hAymQy5pYUq0zOLbuOLM78hNijM6DHO2PUFpnQfiAldH8LmC8cwZedKHHn+/9S2VReHEAIv/LICu5/+F7o3D0Fm0W10W/MPPNmxNzydXHUum7niL6gowcQdn2LvM28jwr81DmWdx8QdnyJl0vsAgO9GzEIzF3cAwJb0REz5dSVOTlysc5otGt0byLgNFJTp177uIfK6Hkx/Lz8P4ImehscmVbrWUz9XT5yYuEj5+4eJ2/H79TT4unoA0L4OTuk+EI+1jYJMJsOKpAS8lLAae575l1Hi0qedrhxfN+JVtQWlqccGY42/po7TGgV6AyOigZ9O6v+ehowDw6OAoGaGRGZ++uaXphzRte0xZ4yA9u8TmnLVWP1LKZc8XIBxscD/DgBCz/c0JAf6drD+nbvG+nwbsn4Zsm6bcv0yJA5d256G5pmlWOk+RzK3B4LD0dpT+3lcpVUVWHtmP97tPxayP8/DDHRvppwuF3K8lLAKHw2cCGd7R6PGd6u0CCdvZuDZLv0BKBIxqzgflwrqP6RNWxwyyFBUoXi44d2qcvi5esDZ3lHnspkz/iuFt+Dr6qHcc96/dWdcL85H8s0MAFAWDABwt7IMMvx1Tqy2abbI3Rl45RHAy0W/9h/+qnjQvK4H09fxdlXM31r3TBubIetpnbVn9mNSt4eVv2taB10cnDC0XbQyv2JbdsDVu/pdEKlvXNraNTTHTT02AMYZf80Rp7V6qDPwSBf92xs6DgwMBx7u3LDYzEXf/NKWI7q2PeaKETDN9wl9+5diLkW0BsbG6t/e0ByIDFEcEbZmlvx8DVm3Tbl+Gbqd1WfbIyVN8kgtNczlolvwdXHH4mNbse/qWbg6OOFffUdjYBvFY5E+OvEL4lp1Qo/AdkbvO6s4H4HuzeBgZw8AkMlkCPbyw/Xi/HqnVWiKQyaTYd2IVzF22zK4O7igoLIU34/6O5zsHXD+zg2ty2bO+MN8AnGnvARHsi8irlVH/HzpJIqrypFZdBvRLdoCACb9sgIHrivuzr31qXiV92ubZouaewGvPgqs3GfcG0c19wReGqg4UttUGLKeAsCR7IsorCjFsPaqFzjrsw4uT/oVI8L0OwSub1za2pXVVOnM8Rd/+QwCQO/A9njvwWfQ3M1L57hnLrrisJY4LWV4FODsAPxy2rjzHdINeKyb9K6n15Rf2nKkR4u2Orc95ogR0P19Ql2uGqt/qeZSXJji9PiNx4BaI56O37sd8Eys9Z56r0ljPt/Grl/a1m1zrl+GbGfVMUaemROLWtJbrbwWV+/mIdyvFRY+OA7JNzPx+A8LkfLCf3C77C5+ungc+5552+D5PrDubVwqVH8k6PjzixDspf9epLO3r2uMo0Zei0VHtuD7ka/hgeBwnMi5jKe2fICkiYu1LlsLd+9GL4MhvJ3dsGHkbLx1cANKqivQJ6gDwv1aKb+EAMDax18BAHx99nfM+309to2eq9c0W9XcE5jzOLA1CThyqfHze6Djn1+SjXvCgc1Ze2Y/xkc8oLJuArrXwcVHt+ByQS5WjJ1nrlB15vjeZ95GiJc/qmtr8PahTZi88zNsGz3X5GODvuObrjgaG6fUyWTAo92Ats2B9UeBO6WNm5+POzCuD9BRv0u+rUpD80ufbY8mhq7n2mLUth0HoDFXDaGtfynnUkw7oLUP8N0RIKugcfNyc1Icne0RKr2dOo35fBu7funKv8asX4bkWWO3s8bIM3NjUUt6C/b0g51MhmfDFactRbcIRahXAM7mXcOlglxcvZuHLl+8DgDILS1C2q4vkFtaiOlRg7XO9+D4d3X23drTD7mlhaiR18LBzh5CCFy/m4/g+06bOJx9XmMcvQLb40ZpAR4IVty6r1dQe7Ty8EXKrauICmijcdlauHfTGZ+uZXC2d9Ar/joPh0Tg4ZAIAIobCgR/9jLC/epfzDKh64OYuecL5JcXw8/VU+9ptsjFUXETi6gQ4JdTwNV8w+fR1h94PAro0EQf3aNvngFASVUFfrhwFH8892+N81O3Dn6YuB1b0hPx65h/ws3R2ahxaWvXzNlNa46HePkDABztHTCr52OI+OINANrHPWOMDfrSFUdj47QVHQKBucOAX88odnBVVBv2fhdHxSNLHuuu+L/U6MovXbmk77bnfoas57pi1LYdnx41WGOuGqt/qedSSx/gtceA39KA388Ddw28gZSDnaKQHR6leCat1DT2823M+qXP9q0x65e+edaQ7ez9GptnliCxkwnIkvzdvDAwpCt2ZZ4CAGQU3kLm3Vvo7NsK06MG49rLK5A+7WOkT/sYsUFhWPHoZGVBO+mXFdiSntjgvgPcvREdEIrvUg8BAH68eBytPH3rnRKpLY7Wnn7ILSlEWn42ACiuISq6iY6+QVqXrU5jlkHf+OvklPy1i/W9oz/h4ZAIhPkEorCiFDfumbY1PRF+Lp7wdfHQOq0p6RSk2KC/8Zjiy6mPm/b2Pu6K07b+MRSYPaTpFrSAYevppgtH0D0gBJ3v+cKrax386MQObDz/B3aOeVPl2ltAe37pG5e2dtpyvLSqAoUVfx3a23j+D0T9eddwXWNDY8c2femKQ58xrKlwdlQ88mvBU4odXW2bA45aDjY62ivajI0BFjypuDGcFAtabflVR1cuadr2AMZZ1/WJUdt2XFuu6hOjPv3bQi7Z2wGDIoC3nwAm9ldsF7Wt03YyxRHeEVHAO08q7vQtxYK2sZ9vY9YvffrW1b+uPvShbxza6Po7WCuZEELfm6WRhImqGtTM26Rx+iu7/oedV1KQW1oIP1cPeDq5Im3KMgDA9IRVGN6+J0aE9cSVwpuYnrAaeeXFsJPJMC/uKTzVMabe/AZt+Dde7fmY8hb83dfMwdrHX0bPRlxve+HODUzZuRL5FSXwcnLF6semo1vzkHoxaotjQ9ofWHJsK+xkMsiFQHzsSIwL7wcAOpetsctgSPwvJazGoezzqJXLEduyAz4aOBHNXNxxteg2xv38X5TXVMNOJkNzV08sfng8ogJCtU5Tx+G9MZA5NY2TNUoqgOt3FHd6rJUDDvaKDXZrH8WdI5sSXWOBvuvpg9/Nx+RuAzDxnptEaVsHs4rz0e7zV9HOOwAeTopvS872Djj855FeXfmlb1za2mnK8SuFN/H0to9QK5dDAGjrHYAPB05AqHdzre/TJ259GGv81Xd8BppW/gOKvL9ZBOQUAdU1irvEOjkAQd5AC2/pXC+oKX915Ze+OaJp2wM0fl03JMZ73bsd15Wr2mI0pH99c0lKeSQXQF4xcKMAqKgBhFDs0AnwUtzZW9uOH2tijBxo6LZA0/pl6Lptqm2Krjjuj0XTtkfX3+Fe1pQDLGqbCF1fZE3pdtldTNjxCXaO+adF+jcGW1iG+1nTQETmY8mxQBOp5pdU4waY/1JlqfyVwrpuiRiZR+ZnyzkghTy7nzXlAIvaJsIav8iSZVnTQETmw7GAAOa/VDF/rQvzyPyYA9bFmnJAIifcEBEREREREdXHopaIiIiIiIgki0UtERERERERSRavqW0ihBBAda2lwyBr4mgPmdSeqE6NxrGAADD/JYr5a2WYR2bHHLAyVpQDLGqJiIiIiIhIsnj6MREREREREUkWi1oiIiIiIiKSLBa1REREREREJFksaomIiIiIiEiyWNQSERERERGRZLGoJSIiIiIiIsliUUtERERERESSxaKWiIiIiIiIJItFLREREREREUkWi1oiIiIiIiKSLBa1REREREREJFksaomIiIiIiEiyWNQSERERERGRZLGoJSIiIiIiIsliUUtERERERESSxaKWiIiIiIiIJItFLREREREREUkWi1oiIiIiIiKSLBa1REREREREJFksaomIiIiIiEiyWNQSERERERGRZLGoJSIiIiIiIsliUUtERERERESSxaKWiIiIiIiIJItFLREREREREUnW/wf0C+FWZAOP5QAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, "execution_count": 5, @@ -272,7 +272,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -317,34 +317,20 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "id": "d7b9a831", "metadata": {}, "outputs": [ { - "ename": "QiskitError", - "evalue": "\"Error decomposing node of instruction 'id': 'NoneType' object has no attribute 'global_phase'. Unable to define instruction 'id' in the given basis.\"", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/miniconda3/envs/vqls_prototype/lib/python3.8/site-packages/qiskit/transpiler/passes/basis/unroller.py:77\u001b[0m, in \u001b[0;36mUnroller.run\u001b[0;34m(self, dag)\u001b[0m\n\u001b[1;32m 76\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m---> 77\u001b[0m phase \u001b[39m=\u001b[39m node\u001b[39m.\u001b[39;49mop\u001b[39m.\u001b[39;49mdefinition\u001b[39m.\u001b[39;49mglobal_phase\n\u001b[1;32m 78\u001b[0m rule \u001b[39m=\u001b[39m node\u001b[39m.\u001b[39mop\u001b[39m.\u001b[39mdefinition\u001b[39m.\u001b[39mdata\n", - "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'global_phase'", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mQiskitError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/home/nico/QuantumApplicationLab/vqls-prototype/docs/how_tos/04_how_to_comtrol_option.ipynb Cell 18\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m options \u001b[39m=\u001b[39m vqls\u001b[39m.\u001b[39m_validate_solve_options({\u001b[39m\"\u001b[39m\u001b[39muse_local_cost_function\u001b[39m\u001b[39m\"\u001b[39m:\u001b[39mFalse\u001b[39;00m, \u001b[39m\"\u001b[39m\u001b[39mmatrix_decomposition\u001b[39m\u001b[39m\"\u001b[39m:\u001b[39m\"\u001b[39m\u001b[39mpauli\u001b[39m\u001b[39m\"\u001b[39m})\n\u001b[0;32m----> 2\u001b[0m _, qc_test \u001b[39m=\u001b[39m vqls\u001b[39m.\u001b[39;49mconstruct_circuit(A, b, options)\n\u001b[1;32m 3\u001b[0m qc_test[\u001b[39m0\u001b[39m]\u001b[39m.\u001b[39mcircuits[\u001b[39m0\u001b[39m]\u001b[39m.\u001b[39mdecompose()\u001b[39m.\u001b[39mdraw(\u001b[39m'\u001b[39m\u001b[39mmpl\u001b[39m\u001b[39m'\u001b[39m)\n", - "File \u001b[0;32m~/QuantumApplicationLab/vqls-prototype/vqls_prototype/vqls.py:354\u001b[0m, in \u001b[0;36mVQLS.construct_circuit\u001b[0;34m(self, matrix, vector, options)\u001b[0m\n\u001b[1;32m 350\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mFormat of the input matrix not recognized\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 352\u001b[0m \u001b[39m# create only the circuit for = <0|V A_n ^* A_m V|0>\u001b[39;00m\n\u001b[1;32m 353\u001b[0m \u001b[39m# with n != m as the diagonal terms (n==m) always give a proba of 1.0\u001b[39;00m\n\u001b[0;32m--> 354\u001b[0m hdmr_tests_norm \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_get_norm_circuits()\n\u001b[1;32m 356\u001b[0m \u001b[39m# create the circuits for \u001b[39;00m\n\u001b[1;32m 357\u001b[0m \u001b[39m# local cost function\u001b[39;00m\n\u001b[1;32m 358\u001b[0m \u001b[39mif\u001b[39;00m options[\u001b[39m\"\u001b[39m\u001b[39muse_local_cost_function\u001b[39m\u001b[39m\"\u001b[39m]:\n", - "File \u001b[0;32m~/QuantumApplicationLab/vqls-prototype/vqls_prototype/vqls.py:381\u001b[0m, in \u001b[0;36mVQLS._get_norm_circuits\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 379\u001b[0m \u001b[39mfor\u001b[39;00m jj \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(ii \u001b[39m+\u001b[39m \u001b[39m1\u001b[39m, \u001b[39mlen\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmatrix_circuits)):\n\u001b[1;32m 380\u001b[0m mj \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmatrix_circuits[jj]\n\u001b[0;32m--> 381\u001b[0m hdmr_tests_norm\u001b[39m.\u001b[39mappend( HadammardTest(\n\u001b[1;32m 382\u001b[0m operators\u001b[39m=\u001b[39;49m[mi\u001b[39m.\u001b[39;49mcircuit\u001b[39m.\u001b[39;49minverse(), mj\u001b[39m.\u001b[39;49mcircuit],\n\u001b[1;32m 383\u001b[0m apply_initial_state\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_ansatz,\n\u001b[1;32m 384\u001b[0m apply_measurement\u001b[39m=\u001b[39;49m\u001b[39mFalse\u001b[39;49;00m\n\u001b[1;32m 385\u001b[0m )\n\u001b[1;32m 386\u001b[0m )\n\u001b[1;32m 387\u001b[0m \u001b[39mreturn\u001b[39;00m hdmr_tests_norm\n", - "File \u001b[0;32m~/QuantumApplicationLab/vqls-prototype/vqls_prototype/hadamard_test.py:61\u001b[0m, in \u001b[0;36mHadammardTest.__init__\u001b[0;34m(self, operators, use_barrier, apply_control_to_operator, apply_initial_state, apply_measurement)\u001b[0m\n\u001b[1;32m 58\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_clbits \u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m 60\u001b[0m \u001b[39m# build the circuits\u001b[39;00m\n\u001b[0;32m---> 61\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcircuits \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_build_circuit(\n\u001b[1;32m 62\u001b[0m operators,\n\u001b[1;32m 63\u001b[0m use_barrier,\n\u001b[1;32m 64\u001b[0m apply_control_to_operator,\n\u001b[1;32m 65\u001b[0m apply_initial_state,\n\u001b[1;32m 66\u001b[0m apply_measurement,\n\u001b[1;32m 67\u001b[0m )\n\u001b[1;32m 69\u001b[0m \u001b[39m# number of circuits required\u001b[39;00m\n\u001b[1;32m 70\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mncircuits \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcircuits)\n", - "File \u001b[0;32m~/QuantumApplicationLab/vqls-prototype/vqls_prototype/hadamard_test.py:131\u001b[0m, in \u001b[0;36mHadammardTest._build_circuit\u001b[0;34m(self, operators, use_barrier, apply_control_to_operator, apply_initial_state, apply_measurement)\u001b[0m\n\u001b[1;32m 128\u001b[0m \u001b[39mfor\u001b[39;00m op, ctrl \u001b[39min\u001b[39;00m \u001b[39mzip\u001b[39m(operators, apply_control_to_operator):\n\u001b[1;32m 129\u001b[0m \u001b[39mif\u001b[39;00m ctrl:\n\u001b[1;32m 130\u001b[0m qc\u001b[39m.\u001b[39mappend(\n\u001b[0;32m--> 131\u001b[0m op\u001b[39m.\u001b[39;49mcontrol(\u001b[39m1\u001b[39;49m),\n\u001b[1;32m 132\u001b[0m \u001b[39mlist\u001b[39m(\u001b[39mrange\u001b[39m(\u001b[39m0\u001b[39m, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_qubits))\n\u001b[1;32m 133\u001b[0m )\n\u001b[1;32m 134\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 135\u001b[0m qc\u001b[39m.\u001b[39mappend(op, \u001b[39mlist\u001b[39m(\u001b[39mrange\u001b[39m(\u001b[39m0\u001b[39m, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_qubits)))\n", - "File \u001b[0;32m~/miniconda3/envs/vqls_prototype/lib/python3.8/site-packages/qiskit/circuit/quantumcircuit.py:777\u001b[0m, in \u001b[0;36mQuantumCircuit.control\u001b[0;34m(self, num_ctrl_qubits, label, ctrl_state)\u001b[0m\n\u001b[1;32m 770\u001b[0m \u001b[39mexcept\u001b[39;00m QiskitError \u001b[39mas\u001b[39;00m ex:\n\u001b[1;32m 771\u001b[0m \u001b[39mraise\u001b[39;00m CircuitError(\n\u001b[1;32m 772\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mThe circuit contains non-unitary operations and cannot be \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 773\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mcontrolled. Note that no qiskit.circuit.Instruction objects may \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 774\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mbe in the circuit for this operation.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 775\u001b[0m ) \u001b[39mfrom\u001b[39;00m \u001b[39mex\u001b[39;00m\n\u001b[0;32m--> 777\u001b[0m controlled_gate \u001b[39m=\u001b[39m gate\u001b[39m.\u001b[39;49mcontrol(num_ctrl_qubits, label, ctrl_state)\n\u001b[1;32m 778\u001b[0m control_qreg \u001b[39m=\u001b[39m QuantumRegister(num_ctrl_qubits)\n\u001b[1;32m 779\u001b[0m controlled_circ \u001b[39m=\u001b[39m QuantumCircuit(\n\u001b[1;32m 780\u001b[0m control_qreg, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mqubits, \u001b[39m*\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mqregs, name\u001b[39m=\u001b[39m\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mc_\u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mname\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m\n\u001b[1;32m 781\u001b[0m )\n", - "File \u001b[0;32m~/miniconda3/envs/vqls_prototype/lib/python3.8/site-packages/qiskit/circuit/gate.py:121\u001b[0m, in \u001b[0;36mGate.control\u001b[0;34m(self, num_ctrl_qubits, label, ctrl_state)\u001b[0m\n\u001b[1;32m 118\u001b[0m \u001b[39m# pylint: disable=cyclic-import\u001b[39;00m\n\u001b[1;32m 119\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m\u001b[39madd_control\u001b[39;00m \u001b[39mimport\u001b[39;00m add_control\n\u001b[0;32m--> 121\u001b[0m \u001b[39mreturn\u001b[39;00m add_control(\u001b[39mself\u001b[39;49m, num_ctrl_qubits, label, ctrl_state)\n", - "File \u001b[0;32m~/miniconda3/envs/vqls_prototype/lib/python3.8/site-packages/qiskit/circuit/add_control.py:59\u001b[0m, in \u001b[0;36madd_control\u001b[0;34m(operation, num_ctrl_qubits, label, ctrl_state)\u001b[0m\n\u001b[1;32m 56\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(operation, UnitaryGate):\n\u001b[1;32m 57\u001b[0m \u001b[39m# attempt decomposition\u001b[39;00m\n\u001b[1;32m 58\u001b[0m operation\u001b[39m.\u001b[39m_define()\n\u001b[0;32m---> 59\u001b[0m cgate \u001b[39m=\u001b[39m control(operation, num_ctrl_qubits\u001b[39m=\u001b[39;49mnum_ctrl_qubits, label\u001b[39m=\u001b[39;49mlabel, ctrl_state\u001b[39m=\u001b[39;49mctrl_state)\n\u001b[1;32m 60\u001b[0m cgate\u001b[39m.\u001b[39mbase_gate\u001b[39m.\u001b[39mlabel \u001b[39m=\u001b[39m operation\u001b[39m.\u001b[39mlabel\n\u001b[1;32m 61\u001b[0m \u001b[39mreturn\u001b[39;00m cgate\n", - "File \u001b[0;32m~/miniconda3/envs/vqls_prototype/lib/python3.8/site-packages/qiskit/circuit/add_control.py:113\u001b[0m, in \u001b[0;36mcontrol\u001b[0;34m(operation, num_ctrl_qubits, label, ctrl_state)\u001b[0m\n\u001b[1;32m 111\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(operation, controlledgate\u001b[39m.\u001b[39mControlledGate):\n\u001b[1;32m 112\u001b[0m operation\u001b[39m.\u001b[39mctrl_state \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m--> 113\u001b[0m unrolled_gate \u001b[39m=\u001b[39m _unroll_gate(operation, basis_gates\u001b[39m=\u001b[39;49mbasis)\n\u001b[1;32m 114\u001b[0m \u001b[39mif\u001b[39;00m unrolled_gate\u001b[39m.\u001b[39mdefinition\u001b[39m.\u001b[39mglobal_phase:\n\u001b[1;32m 115\u001b[0m global_phase \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m unrolled_gate\u001b[39m.\u001b[39mdefinition\u001b[39m.\u001b[39mglobal_phase\n", - "File \u001b[0;32m~/miniconda3/envs/vqls_prototype/lib/python3.8/site-packages/qiskit/circuit/add_control.py:269\u001b[0m, in \u001b[0;36m_unroll_gate\u001b[0;34m(operation, basis_gates)\u001b[0m\n\u001b[1;32m 267\u001b[0m unroller \u001b[39m=\u001b[39m Unroller(basis_gates)\n\u001b[1;32m 268\u001b[0m dag \u001b[39m=\u001b[39m _gate_to_dag(operation)\n\u001b[0;32m--> 269\u001b[0m opqc \u001b[39m=\u001b[39m dag_to_circuit(unroller\u001b[39m.\u001b[39;49mrun(dag))\n\u001b[1;32m 270\u001b[0m \u001b[39mreturn\u001b[39;00m opqc\u001b[39m.\u001b[39mto_gate()\n", - "File \u001b[0;32m~/miniconda3/envs/vqls_prototype/lib/python3.8/site-packages/qiskit/transpiler/passes/basis/unroller.py:80\u001b[0m, in \u001b[0;36mUnroller.run\u001b[0;34m(self, dag)\u001b[0m\n\u001b[1;32m 78\u001b[0m rule \u001b[39m=\u001b[39m node\u001b[39m.\u001b[39mop\u001b[39m.\u001b[39mdefinition\u001b[39m.\u001b[39mdata\n\u001b[1;32m 79\u001b[0m \u001b[39mexcept\u001b[39;00m (\u001b[39mTypeError\u001b[39;00m, \u001b[39mAttributeError\u001b[39;00m) \u001b[39mas\u001b[39;00m err:\n\u001b[0;32m---> 80\u001b[0m \u001b[39mraise\u001b[39;00m QiskitError(\n\u001b[1;32m 81\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mError decomposing node of instruction \u001b[39m\u001b[39m'\u001b[39m\u001b[39m{\u001b[39;00mnode\u001b[39m.\u001b[39mname\u001b[39m}\u001b[39;00m\u001b[39m'\u001b[39m\u001b[39m: \u001b[39m\u001b[39m{\u001b[39;00merr\u001b[39m}\u001b[39;00m\u001b[39m. \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 82\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mUnable to define instruction \u001b[39m\u001b[39m'\u001b[39m\u001b[39m{\u001b[39;00mnode\u001b[39m.\u001b[39mname\u001b[39m}\u001b[39;00m\u001b[39m'\u001b[39m\u001b[39m in the given basis.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 83\u001b[0m ) \u001b[39mfrom\u001b[39;00m \u001b[39merr\u001b[39;00m\n\u001b[1;32m 85\u001b[0m \u001b[39m# Isometry gates definitions can have widths smaller than that of the\u001b[39;00m\n\u001b[1;32m 86\u001b[0m \u001b[39m# original gate, in which case substitute_node will raise. Fall back\u001b[39;00m\n\u001b[1;32m 87\u001b[0m \u001b[39m# to substitute_node_with_dag if an the width of the definition is\u001b[39;00m\n\u001b[1;32m 88\u001b[0m \u001b[39m# different that the width of the node.\u001b[39;00m\n\u001b[1;32m 89\u001b[0m \u001b[39mwhile\u001b[39;00m rule \u001b[39mand\u001b[39;00m \u001b[39mlen\u001b[39m(rule) \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m \u001b[39mand\u001b[39;00m \u001b[39mlen\u001b[39m(node\u001b[39m.\u001b[39mqargs) \u001b[39m==\u001b[39m \u001b[39mlen\u001b[39m(rule[\u001b[39m0\u001b[39m]\u001b[39m.\u001b[39mqubits) \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m:\n", - "\u001b[0;31mQiskitError\u001b[0m: \"Error decomposing node of instruction 'id': 'NoneType' object has no attribute 'global_phase'. Unable to define instruction 'id' in the given basis.\"" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ diff --git a/docs/technical_docs.md b/docs/technical_docs.md index 288b598..b843658 100644 --- a/docs/technical_docs.md +++ b/docs/technical_docs.md @@ -1,3 +1,7 @@ # VQLS Technical Docs +* [matrix_decomposition](apidocs/matrix_decomposition.md) +* [hadamard_test](apidocs/hadamard_test.md) +* [vqls](apidocs/vqls.md) +* [variational_linear_solver](apidocs/variational_linear_solver.md) diff --git a/vqls_prototype/hadamard_test.py b/vqls_prototype/hadamard_test.py index 3c3c6bf..4ab67ae 100644 --- a/vqls_prototype/hadamard_test.py +++ b/vqls_prototype/hadamard_test.py @@ -3,7 +3,7 @@ from typing import Optional, List, Union from qiskit import QuantumCircuit, QuantumRegister from qiskit.algorithms.exceptions import AlgorithmError -from qiskit.opflow import Z, I, TensoredOp +from qiskit.opflow import TensoredOp from qiskit.quantum_info import SparsePauliOp import numpy as np From c2cb5cbb18c12e87e4666c666cc828a38af08187 Mon Sep 17 00:00:00 2001 From: Nicolas Renaud Date: Thu, 4 May 2023 09:29:30 +0200 Subject: [PATCH 2/3] clean api doc --- docs/apidocs/vqls.md | 50 +++++++++++++++++++++++++++----------------- 1 file changed, 31 insertions(+), 19 deletions(-) diff --git a/docs/apidocs/vqls.md b/docs/apidocs/vqls.md index de1f185..eb617e5 100644 --- a/docs/apidocs/vqls.md +++ b/docs/apidocs/vqls.md @@ -42,37 +42,49 @@ update(count, cost, parameters) Systems of linear equations arise naturally in many real-life applications in a wide range of areas, such as in the solution of Partial Differential Equations, the calibration of financial models, fluid simulation or numerical field calculation. The problem can be defined as, given a matrix :math:`A\in\mathbb{C}^{N\times N}` and a vector :math:`\vec{b}\in\mathbb{C}^{N}`, find :math:`\vec{x}\in\mathbb{C}^{N}` satisfying :math:`A\vec{x}=\vec{b}`. +```python + from qalcore.qiskit.vqls.vqls import VQLS, VQLSLog + from qiskit.circuit.library.n_local.real_amplitudes import RealAmplitudes + from qiskit.algorithms import optimizers as opt + from qiskit import Aer, BasicAer + import numpy as np -**Examples:** - - - .. jupyter-execute: - - from qalcore.qiskit.vqls.vqls import VQLS, VQLSLog from qiskit.circuit.library.n_local.real_amplitudes import RealAmplitudes from qiskit.algorithms import optimizers as opt from qiskit import Aer, BasicAer import numpy as np - - from qiskit.quantum_info import Statevector import matplotlib.pyplot as plt from qiskit.primitives import Estimator, Sampler, BackendEstimator + from qiskit.quantum_info import Statevector + import matplotlib.pyplot as plt f + rom qiskit.primitives import Estimator, Sampler, BackendEstimator - # create random symmetric matrix A = np.random.rand(4, 4) A = A + A.T + # create random symmetric matrix + A = np.random.rand(4, 4) A = A + A.T - # create rhight hand side b = np.random.rand(4) + # create rhight hand side + b = np.random.rand(4) - # solve using numpy classical_solution = np.linalg.solve(A, b / np.linalg.norm(b)) ref_solution = classical_solution / np.linalg.norm(classical_solution) + # solve using numpy + classical_solution = np.linalg.solve(A, b / np.linalg.norm(b)) + ref_solution = classical_solution / np.linalg.norm(classical_solution) - # define the wave function ansatz ansatz = RealAmplitudes(2, entanglement="full", reps=3, insert_barriers=False) + # define the wave function ansatz + ansatz = RealAmplitudes(2, entanglement="full", reps=3, insert_barriers=False) - # define backend backend = BasicAer.get_backend("statevector_simulator") + # define an estimator primitive + estimator = Estimator() - # define an estimator primitive estimator = Estimator() + # define the logger + log = VQLSLog([],[]) - # define the logger log = VQLSLog([],[]) + # create the solver + vqls = VQLS( estimator, ansatz, opt.CG(maxiter=200), callback=log.update ) - # create the solver vqls = VQLS( estimator, ansatz, opt.CG(maxiter=200), callback=log.update ) + # solve + res = vqls.solve(A, b, opt) vqls_solution = np.real(Statevector(res.state).data) - # solve res = vqls.solve(A, b, opt) vqls_solution = np.real(Statevector(res.state).data) + # plot solution + plt.scatter(ref_solution, vqls_solution) plt.plot([-1, 1], [-1, 1], "--") plt.show() - # plot solution plt.scatter(ref_solution, vqls_solution) plt.plot([-1, 1], [-1, 1], "--") plt.show() + # plot cost function + plt.plot(log.values) plt.ylabel('Cost Function') plt.xlabel('Iterations') plt.show() - # plot cost function plt.plot(log.values) plt.ylabel('Cost Function') plt.xlabel('Iterations') plt.show() + ``` References: From 1e931a4316dfe782837f3c6d42b595e18f0851e3 Mon Sep 17 00:00:00 2001 From: Nicolas Renaud Date: Thu, 4 May 2023 10:45:32 +0200 Subject: [PATCH 3/3] fix matrix api --- docs/apidocs/matrix_decomposition.md | 116 +++++++++----------- vqls_prototype/matrix_decomposition.py | 146 ++++++++++--------------- 2 files changed, 107 insertions(+), 155 deletions(-) diff --git a/docs/apidocs/matrix_decomposition.md b/docs/apidocs/matrix_decomposition.md index ce8dcd7..7a13de6 100644 --- a/docs/apidocs/matrix_decomposition.md +++ b/docs/apidocs/matrix_decomposition.md @@ -18,7 +18,7 @@ Base class for the decomposition of a matrix in quantum circuits. - + ### method `__init__` @@ -32,12 +32,13 @@ __init__( Decompose a matrix representing quantum circuits -Parameters ----------- matrix : npt.NDArray Array to decompose; only relevant in derived classes where `self.decompose_matrix()` has been implemented -circuits : Union[QuantumCircuit, List[QuantumCircuit]] quantum circuits representing the matrix -coefficients : Union[float, complex, List[float], List[complex]] (default: None) coefficients associated with the input quantum circuits; `None` is valid only for a circuit with 1 element +**Args:** + + - `matrix` (Optional[npt.NDArray], optional): Array to decompose; only relevant in derived classes where `self.decompose_matrix()` has been implemented. Defaults to None. + - `circuits` (Optional[Union[QuantumCircuit, List[QuantumCircuit]]], optional): quantum circuits representing the matrix. Defaults to None. + - `coefficients` (Optional[ Union[float, complex, List[float], List[complex]] ], optional): coefficients associated with the input quantum circuits; `None` is valid only for a circuit with 1 element. Defaults to None. --- @@ -68,7 +69,7 @@ matrix of the decomposition --- - + ### method `decompose_matrix` @@ -82,7 +83,7 @@ decompose_matrix() → Tuple[ndarray[Any, dtype[complex128]], List[ndarray[Any, --- - + ### method `recompose` @@ -92,27 +93,21 @@ recompose() → ndarray[Any, dtype[complex128]] Rebuilds the original matrix from the decomposed one. -Returns -------- np.ndarray The recomposed matrix. -See Also --------- decompose_matrix : Decompose a generic numpy matrix into a sum of unitary matrices. + +**Returns:** + + - `complex_arr_t`: The recomposed matrix. --- - + ## class `SymmetricDecomposition` A class that represents the symmetric decomposition of a matrix. For the mathematical background for the decomposition, see the following math.sx answer: https://math.stackexchange.com/a/1710390 -Methods -------- decompose_matrix() -> Tuple[complex_arr_t, List[complex_arr_t]]: Decompose a generic numpy matrix into a sum of unitary matrices. - -See Also --------- MatrixDecomposition : A base class for matrix decompositions. recompose : Rebuilds the original matrix from the decomposed one. - - + ### method `__init__` @@ -126,12 +121,13 @@ __init__( Decompose a matrix representing quantum circuits -Parameters ----------- matrix : npt.NDArray Array to decompose; only relevant in derived classes where `self.decompose_matrix()` has been implemented -circuits : Union[QuantumCircuit, List[QuantumCircuit]] quantum circuits representing the matrix -coefficients : Union[float, complex, List[float], List[complex]] (default: None) coefficients associated with the input quantum circuits; `None` is valid only for a circuit with 1 element +**Args:** + + - `matrix` (Optional[npt.NDArray], optional): Array to decompose; only relevant in derived classes where `self.decompose_matrix()` has been implemented. Defaults to None. + - `circuits` (Optional[Union[QuantumCircuit, List[QuantumCircuit]]], optional): quantum circuits representing the matrix. Defaults to None. + - `coefficients` (Optional[ Union[float, complex, List[float], List[complex]] ], optional): coefficients associated with the input quantum circuits; `None` is valid only for a circuit with 1 element. Defaults to None. --- @@ -162,7 +158,7 @@ matrix of the decomposition --- - + ### method `auxilliary_matrix` @@ -172,20 +168,23 @@ auxilliary_matrix( ) → ndarray[Any, dtype[complex128]] ``` -Returns the auxiliary matrix for the decomposition of size n. +Returns the auxiliary matrix for the decomposition of size n and derfined as defined as : i * sqrt(I - x^2) -Parameters ----------- x : np.ndarray original matrix. -Returns -------- np.ndarray The auxiliary matrix. -Notes ------ The auxiliary matrix is defined as : i * sqrt(I - x^2) +**Args:** + + - `x` (Union[npt.NDArray[np.float_], complex_arr_t]): original matrix. + + + +**Returns:** + + - `complex_arr_t`: The auxiliary matrix. --- - + ### method `decompose_matrix` @@ -195,18 +194,15 @@ decompose_matrix() → Tuple[ndarray[Any, dtype[complex128]], List[ndarray[Any, Decompose a generic numpy matrix into a sum of unitary matrices. -Parameters ----------- matrix : np.ndarray The matrix to be decomposed. -Returns -------- Tuple[np.ndarray, np.ndarray] A tuple containing the list of coefficients and the numpy matrix of the decomposition. -See Also --------- recompose : Rebuilds the original matrix from the decomposed one. +**Returns:** + + - `Tuple[complex_arr_t, List[complex_arr_t], List[QuantumCircuit]]`: A tuple containing the list of coefficients numpy matrices, and quantum circuits of the decomposition. --- - + ### method `recompose` @@ -216,30 +212,21 @@ recompose() → ndarray[Any, dtype[complex128]] Rebuilds the original matrix from the decomposed one. -Returns -------- np.ndarray The recomposed matrix. -See Also --------- decompose_matrix : Decompose a generic numpy matrix into a sum of unitary matrices. + +**Returns:** + + - `complex_arr_t`: The recomposed matrix. --- - + ## class `PauliDecomposition` A class that represents the Pauli decomposition of a matrix. -Attributes ----------- basis : str The basis of Pauli gates used for the decomposition. - -Methods -------- decompose_matrix() -> Tuple[complex_arr_t, List[complex_arr_t]]: Decompose a matrix into a sum of Pauli strings. - -See Also --------- MatrixDecomposition : A base class for matrix decompositions. - - + ### method `__init__` @@ -253,12 +240,13 @@ __init__( Decompose a matrix representing quantum circuits -Parameters ----------- matrix : npt.NDArray Array to decompose; only relevant in derived classes where `self.decompose_matrix()` has been implemented -circuits : Union[QuantumCircuit, List[QuantumCircuit]] quantum circuits representing the matrix -coefficients : Union[float, complex, List[float], List[complex]] (default: None) coefficients associated with the input quantum circuits; `None` is valid only for a circuit with 1 element +**Args:** + + - `matrix` (Optional[npt.NDArray], optional): Array to decompose; only relevant in derived classes where `self.decompose_matrix()` has been implemented. Defaults to None. + - `circuits` (Optional[Union[QuantumCircuit, List[QuantumCircuit]]], optional): quantum circuits representing the matrix. Defaults to None. + - `coefficients` (Optional[ Union[float, complex, List[float], List[complex]] ], optional): coefficients associated with the input quantum circuits; `None` is valid only for a circuit with 1 element. Defaults to None. --- @@ -289,7 +277,7 @@ matrix of the decomposition --- - + ### method `decompose_matrix` @@ -306,7 +294,7 @@ Decompose a generic numpy matrix into a sum of Pauli strings. --- - + ### method `recompose` @@ -316,11 +304,11 @@ recompose() → ndarray[Any, dtype[complex128]] Rebuilds the original matrix from the decomposed one. -Returns -------- np.ndarray The recomposed matrix. -See Also --------- decompose_matrix : Decompose a generic numpy matrix into a sum of unitary matrices. + +**Returns:** + + - `complex_arr_t`: The recomposed matrix. diff --git a/vqls_prototype/matrix_decomposition.py b/vqls_prototype/matrix_decomposition.py index 80f2a0a..6181132 100644 --- a/vqls_prototype/matrix_decomposition.py +++ b/vqls_prototype/matrix_decomposition.py @@ -24,7 +24,14 @@ class MatrixDecomposition: def _as_complex( cls, num_or_arr: Union[complex_t, List[complex_t]] ) -> complex_arr_t: - """Converts a number or a list of numbers to a complex array.""" + """Converts a number or a list of numbers to a complex array. + + Args: + num_or_arr (Union[complex_t, List[complex_t]]): array of number to convert + + Returns: + complex_arr_t: array of complex numbers + """ arr = num_or_arr if isinstance(num_or_arr, List) else [num_or_arr] return np.array(arr, dtype=np.cdouble) @@ -38,20 +45,14 @@ def __init__( ): """Decompose a matrix representing quantum circuits - Parameters - ---------- - matrix : npt.NDArray - Array to decompose; only relevant in derived classes where - `self.decompose_matrix()` has been implemented - - circuits : Union[QuantumCircuit, List[QuantumCircuit]] - quantum circuits representing the matrix - - coefficients : Union[float, complex, List[float], List[complex]] (default: None) - coefficients associated with the input quantum circuits; `None` is - valid only for a circuit with 1 element - + Args: + matrix (Optional[npt.NDArray], optional): Array to decompose; only relevant in derived classes where + `self.decompose_matrix()` has been implemented. Defaults to None. + circuits (Optional[Union[QuantumCircuit, List[QuantumCircuit]]], optional): quantum circuits representing the matrix. Defaults to None. + coefficients (Optional[ Union[float, complex, List[float], List[complex]] ], optional): coefficients associated with the input quantum circuits; `None` is + valid only for a circuit with 1 element. Defaults to None. """ + if matrix is not None: # ignore circuits & coefficients self._matrix, self.num_qubits = self._validate_matrix(matrix) self._coefficients, self._matrices, self._circuits = self.decompose_matrix() @@ -92,11 +93,31 @@ def __init__( @classmethod def _compute_circuit_size(cls, matrix: npt.NDArray) -> int: - """Compute the size of the circuit represented by the matrix.""" + """Compute the size of the circuit represented by the matrix + + Args: + matrix (npt.NDArray): matrix representing the circuit + + Returns: + int: circuit size + """ return int(np.log2(matrix.shape[0])) @classmethod def _validate_matrix(cls, matrix: complex_arr_t) -> Tuple[complex_arr_t, int]: + """Check the size of the matrix + + Args: + matrix (complex_arr_t): input matrix + + Raises: + ValueError: if the matrix is not square + ValueError: if the matrix size is not a power of 2 + ValueError: if the matrix is not symmetric + + Returns: + Tuple[complex_arr_t, int]: matrix and the number of qubits required + """ if len(matrix.shape) == 2 and matrix.shape[0] != matrix.shape[1]: raise ValueError( f"Input matrix must be square: matrix.shape={matrix.shape}" @@ -153,17 +174,10 @@ def __getitem__(self, index): return self.CircuitElement(self._coefficients[index], self._circuits[index]) def recompose(self) -> complex_arr_t: - """ - Rebuilds the original matrix from the decomposed one. - - Returns - ------- - np.ndarray - The recomposed matrix. + """Rebuilds the original matrix from the decomposed one. - See Also - -------- - decompose_matrix : Decompose a generic numpy matrix into a sum of unitary matrices. + Returns: + complex_arr_t: The recomposed matrix. """ coeffs, matrices = self.coefficients, self.matrices return (coeffs.reshape(len(coeffs), 1, 1) * matrices).sum(axis=0) @@ -177,30 +191,17 @@ class SymmetricDecomposition(MatrixDecomposition): A class that represents the symmetric decomposition of a matrix. For the mathematical background for the decomposition, see the following math.sx answer: https://math.stackexchange.com/a/1710390 - - Methods - ------- - decompose_matrix() -> Tuple[complex_arr_t, List[complex_arr_t]]: - Decompose a generic numpy matrix into a sum of unitary matrices. - - See Also - -------- - MatrixDecomposition : A base class for matrix decompositions. - recompose : Rebuilds the original matrix from the decomposed one. """ def _create_circuits(self, unimatrices: List[np.ndarray], names: List[str]) -> List[QuantumCircuit]: - """Construct the quantum circuits. + """Construct the quantum circuits from unitary matrices - Parameters - ---------- - unimatrices : List[np.ndarray] - list of unitary matrices of the decomposition. + Args: + unimatrices (List[np.ndarray]): list of unitary matrices of the decomposition. + names (List[str]): names of the circuits - Returns - ------- - List[QuantumCircuit] - list of resulting quantum circuits. + Returns: + List[QuantumCircuit]: quantum circuits """ def make_qc(mat: complex_arr_t, name: str) -> QuantumCircuit: @@ -213,23 +214,13 @@ def make_qc(mat: complex_arr_t, name: str) -> QuantumCircuit: @staticmethod def auxilliary_matrix(x: Union[npt.NDArray[np.float_], complex_arr_t]) -> complex_arr_t: - """ - Returns the auxiliary matrix for the decomposition of size n. - - Parameters - ---------- - x : np.ndarray - original matrix. + """Returns the auxiliary matrix for the decomposition of size n and derfined as defined as : i * sqrt(I - x^2) - Returns - ------- - np.ndarray - The auxiliary matrix. - - Notes - ----- - The auxiliary matrix is defined as : i * sqrt(I - x^2) + Args: + x (Union[npt.NDArray[np.float_], complex_arr_t]): original matrix. + Returns: + complex_arr_t: The auxiliary matrix. """ mat = np.eye(len(x)) - x @ x mat = cast(npt.NDArray[Union[np.float_, np.cdouble]], spla.sqrtm(mat)) @@ -238,23 +229,12 @@ def auxilliary_matrix(x: Union[npt.NDArray[np.float_], complex_arr_t]) -> comple def decompose_matrix( self, ) -> Tuple[complex_arr_t, List[complex_arr_t], List[QuantumCircuit]]: - """ - Decompose a generic numpy matrix into a sum of unitary matrices. - - Parameters - ---------- - matrix : np.ndarray - The matrix to be decomposed. + """Decompose a generic numpy matrix into a sum of unitary matrices. - Returns - ------- - Tuple[np.ndarray, np.ndarray] - A tuple containing the list of coefficients and the numpy matrix of the decomposition. - - See Also - -------- - recompose : Rebuilds the original matrix from the decomposed one. + Returns: + Tuple[complex_arr_t, List[complex_arr_t], List[QuantumCircuit]]: A tuple containing the list of coefficients numpy matrices, and quantum circuits of the decomposition. """ + # Normalize norm = np.linalg.norm(self._matrix) mat = self._matrix / norm @@ -286,23 +266,7 @@ def decompose_matrix( class PauliDecomposition(MatrixDecomposition): - """ - A class that represents the Pauli decomposition of a matrix. - - Attributes - ---------- - basis : str - The basis of Pauli gates used for the decomposition. - - Methods - ------- - decompose_matrix() -> Tuple[complex_arr_t, List[complex_arr_t]]: - Decompose a matrix into a sum of Pauli strings. - - See Also - -------- - MatrixDecomposition : A base class for matrix decompositions. - """ + """A class that represents the Pauli decomposition of a matrix.""" basis = "IXYZ"