From f03eaf0696977a89e92b1026aab8b8e80df09d41 Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Tue, 20 Aug 2024 08:42:54 +0900 Subject: [PATCH 01/26] Add __init__.py files --- src/openqaoa-core/openqaoa/__init__.py | 2 +- src/openqaoa-core/openqaoa/algorithms/__init__.py | 1 + src/openqaoa-core/openqaoa/algorithms/fqaoa/__init__.py | 2 ++ 3 files changed, 4 insertions(+), 1 deletion(-) create mode 100644 src/openqaoa-core/openqaoa/algorithms/fqaoa/__init__.py diff --git a/src/openqaoa-core/openqaoa/__init__.py b/src/openqaoa-core/openqaoa/__init__.py index 4db56ed3a..e1612f08d 100644 --- a/src/openqaoa-core/openqaoa/__init__.py +++ b/src/openqaoa-core/openqaoa/__init__.py @@ -1,3 +1,3 @@ -from .algorithms import QAOA, RQAOA, QAOABenchmark +from .algorithms import QAOA, RQAOA, FQAOA, QAOABenchmark from .problems import QUBO from .backends import create_device diff --git a/src/openqaoa-core/openqaoa/algorithms/__init__.py b/src/openqaoa-core/openqaoa/algorithms/__init__.py index 8c3953e12..2c853b1b5 100644 --- a/src/openqaoa-core/openqaoa/algorithms/__init__.py +++ b/src/openqaoa-core/openqaoa/algorithms/__init__.py @@ -1,2 +1,3 @@ from .qaoa import QAOA, QAOAResult, QAOABenchmark from .rqaoa import RQAOA, RQAOAResult +from .fqaoa import FQAOA diff --git a/src/openqaoa-core/openqaoa/algorithms/fqaoa/__init__.py b/src/openqaoa-core/openqaoa/algorithms/fqaoa/__init__.py new file mode 100644 index 000000000..695ad6a78 --- /dev/null +++ b/src/openqaoa-core/openqaoa/algorithms/fqaoa/__init__.py @@ -0,0 +1,2 @@ +from .fqaoa_workflow import FQAOA, FermiCircuitProperties, GivensRotationGateMap +from .fqaoa_utils import * From 43dbef9e5a46f750469cbdbeffe526f10e35e22c Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Fri, 23 Aug 2024 12:53:52 +0900 Subject: [PATCH 02/26] Add fqaoa_workflow.py --- .../algorithms/fqaoa/fqaoa_workflow.py | 917 ++++++++++++++++++ 1 file changed, 917 insertions(+) create mode 100644 src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py diff --git a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py new file mode 100644 index 000000000..cd16a2f80 --- /dev/null +++ b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py @@ -0,0 +1,917 @@ +from typing import Callable, Optional, Tuple, List, Union, Dict +from copy import deepcopy +import numpy as np + +from .fqaoa_utils import ( + get_analytical_fermi_orbitals, + get_fermi_orbitals, + get_statevector, + get_givens_rotation_angle, +) + +from ..workflow_properties import WorkflowProperties +from ..baseworkflow import Workflow, check_compiled + +from ...backends.devices_core import DeviceBase, DeviceLocal +from ...backends.qaoa_backend import get_qaoa_backend +from ...backends.basebackend import QuantumCircuitBase +from ...problems import QUBO +from ...qaoa_components.ansatz_constructor.gatemap import GateMap +from ...qaoa_components.ansatz_constructor.gatemaplabel import GateMapType, GateMapLabel +from ...qaoa_components.ansatz_constructor.gates import RotationAngle, X, RY, RZ, CX +from ...qaoa_components import ( + Hamiltonian, + QAOADescriptor, + create_qaoa_variational_params, +) +from ...qaoa_components.variational_parameters.variational_baseparams import ( + QAOAVariationalBaseParams, +) +from ...utilities import ( + get_mixer_hamiltonian, + generate_timestamp, +) +from ...optimizers.qaoa_optimizer import get_optimizer +from ...backends.wrapper import SPAMTwirlingWrapper,ZNEWrapper + +ALLOWED_PARAM_TYPES = [ + "standard", + "standard_w_bias", + "extended", + "fourier", + "fourier_extended", + "fourier_w_bias", + "annealing", +] +ALLOWED_INIT_TYPES = ["rand", "ramp", "custom"] +ALLOWED_MIXERS = ["xy"] +ALLOWED_LATTICE = ["cyclic", "chain"] + +class FQAOA(Workflow): + """ + A class implementing a FQAOA workflow end to end. + + It's basic usage consists of + 1. Initialization + 2. Compilation + 3. Optimization + + .. note:: + The attributes of the FQAOA class should be initialized using the set methods of FQAOA. + For example, to set the circuit's depth to 10 you should run `set_circuit_properties(p=10)` + + Attributes + ---------- + device: `DeviceBase` + Device to be used by the optimizer + circuit_properties: `FermiCircuitProperties` + The circuit properties of the FQAOA workflow. Use to set depth `p`, + choice of parameterization, parameter initialisation strategies, mixer hamiltonians. + For a complete list of its parameters and usage please see the method `set_circuit_properties` + backend_properties: `BackendProperties` + The backend properties of the FQAOA workflow. Use to set the backend properties + such as the number of shots and the cvar values. + For a complete list of its parameters and usage please see the method `set_backend_properties` + classical_optimizer: `ClassicalOptimizer` + The classical optimiser properties of the QAOA workflow. Use to set the + classical optimiser needed for the classical optimisation part of the QAOA routine. + For a complete list of its parameters and usage please see the method `set_classical_optimizer` + local_simulators: `list[str]` + A list containing the available local simulators + cloud_provider: `list[str]` + A list containing the available cloud providers + mixer_hamil: Hamiltonian + The desired mixer hamiltonian + cost_hamil: Hamiltonian + The desired mixer hamiltonian + qaoa_descriptor: QAOADescriptor + the abstract and backend-agnostic representation of the underlying QAOA parameters + variate_params: QAOAVariationalBaseParams + The variational parameters. These are the parameters to be optimised by the classical optimiser + backend: VQABaseBackend + The openQAOA representation of the backend to be used to execute the quantum circuit + optimizer: OptimizeVQA + The classical optimiser + result: `Result` + Contains the logs of the optimisation process + compiled: `Bool` + A boolean flag to check whether the QAOA object has been correctly compiled at least once + + Examples + -------- + Examples should be written in doctest format, and should illustrate how + to use the function. + + >>> fqaoa = FQAOA() + >>> fqaoa.fermi_compile(problem, n_fermions) + >>> fqaoa.optimize() + + Where `problem` is an instance of portfolio optimization and `n_fermions` is a constraint value. + + If you want to use non-default parameters: + + >>> fqaoa_custom = FQAOA() + >>> fqaoa_custom.set_circuit_properties( + p=10, + param_type='extended', + init_type='ramp', + ) + >>> device = create_device( + location='aws', + name='arn:aws:braket:::device/quantum-simulator/amazon/sv1', aws_region='us-east-1', + ) + >>> fqaoa_custom.set_device(device) + >>> fqaoa_custom.set_backend_properties(n_shots=200) + >>> fqaoa_custom.set_classical_optimizer(method='nelder-mead', maxiter=2) + >>> fqaoa_custom.fermi_compile(problem, n_fermions) + >>> fqaoa_custom.optimize() + """ + + def __init__(self, device=DeviceLocal("vectorized")): + """ + Initialize the QAOA class. + + Parameters + ---------- + device: `DeviceBase` + Device to be used by the optimizer. Default is using the local 'vectorized' simulator. + """ + super().__init__(device) + self.circuit_properties = FermiCircuitProperties() + self.backend_properties = FermiBackendProperties() + + # Exception handling in FQAOA + if device.device_name == 'analytical_simulator': + raise ValueError("FQAOA cannot be performed on the analytical simulator") + + # change header algorithm to fqaoa + self.header["algorithm"] = "fqaoa" + + @check_compiled + def set_device(self, device: DeviceBase): + """ + Override set_device to add a check for unsupported devices in FQAOA. + + Parameters + ---------- + device: `DeviceBase` + Device to be used by the optimizer. + """ + + if device.device_name == 'analytical_simulator': + raise ValueError("FQAOA cannot be performed on the analytical simulator") + + # Call the parent class's set_device method to handle the rest + super().set_device(device) + + @check_compiled + def set_backend_properties(self, **kwargs): + """ + Override set_backend_properties to use FermiBackendProperties. + + Parameters + ---------- + **kwargs : dict + Keyword arguments representing backend properties. + + - init_hadamard : bool + Whether to apply the Hadamard gate during initialization. This will be overridden to False. + """ + + for key, value in kwargs.items(): + if hasattr(self.backend_properties, key): + pass # setattr(self.backend_properties, key, value) + else: + raise ValueError( + f"Specified argument `{value}` for `{key}` in set_backend_properties is not supported" + ) + + self.backend_properties = FermiBackendProperties(**kwargs) + + return None + @check_compiled + + def set_circuit_properties(self, **kwargs): + """ + Specify the circuit properties to construct QAOA circuit + + Parameters + ---------- + qubit_register: `list` + Select the desired qubits to run the QAOA program. Meant to be used as a qubit + selector for qubits on a QPU. Defaults to a list from 0 to n-1 (n = number of qubits) + p: `int` + Depth `p` of the QAOA circuit + q: `int` + Analogue of `p` of the QAOA circuit in the Fourier parameterization + param_type: `str` + Choose the QAOA circuit parameterization. Currently supported parameterizations include: + `'standard'`: Standard QAOA parameterization + `'standard_w_bias'`: Standard QAOA parameterization with a separate parameter for single-qubit terms. + `'extended'`: Individual parameter for each qubit and each term in the Hamiltonian. + `'fourier'`: Fourier circuit parameterization + `'fourier_extended'`: Fourier circuit parameterization with individual parameter + for each qubit and term in Hamiltonian. + `'fourier_w_bias'`: Fourier circuit parameterization with a separate + parameter for single-qubit terms + init_type: `str` + Initialisation strategy for the QAOA circuit parameters. Allowed init_types: + `'rand'`: Randomly initialise circuit parameters + `'ramp'`: Linear ramp from Hamiltonian initialisation of circuit + parameters (inspired from Quantum Annealing) + `'custom'`: User specified initial circuit parameters + mixer_hamiltonian: `str` + Allowed mixer hamiltonian: + `'xy'`: xy-mixer + mixer_qubit_connectivity: `[Union[List[list],List[tuple], str]]` By default set to 'cyclic' + The connectivity of the qubits in the mixer Hamiltonian. Use only if + `mixer_hamiltonian = xy`. The user can specify the connectivity as a list of lists, + a list of tuples, or a string chosen from ['cyclic', 'chain']. + mixer_coeffs: `list` + The coefficients of the mixer Hamiltonian. By default all set to -1 + annealing_time: `float` + Total time to run the FQAOA program in the Annealing parameterization (digitised annealing) + linear_ramp_time: `float` + The slope(rate) of linear ramp initialisation of QAOA parameters. + variational_params_dict: `dict` + Dictionary object specifying the initial value of each circuit parameter for + the chosen parameterization, if the `init_type` is selected as `'custom'`. + For example, for standard params set {'betas': [0.1, 0.2, 0.3], 'gammas': [0.1, 0.2, 0.3]} + """ + + for key, value in kwargs.items(): + if hasattr(self.circuit_properties, key): + pass + else: + raise ValueError("Specified argument is not supported by the circuit") + self.circuit_properties = FermiCircuitProperties(**kwargs) + + return None + + def compile( + self, + problem: QUBO = None, + n_fermions: int = None, + hopping: float = 1.0, + verbose: bool = False, + routing_function: Optional[Callable] = None, + ): + """ + Prevents usage of the compile method. + """ + + raise NotImplementedError( + "In FQAOA, the compile(problem) method cannot be used; please use fermi_compile(problem, n_femions) instead." + ) + + def fermi_compile( + self, + problem: QUBO = None, + n_fermions: int = None, + hopping: float = 1.0, + verbose: bool = False, + routing_function: Optional[Callable] = None, + ): + """ + Initialise the trainable parameters for FQAOA according to the specified + strategies and by passing the problem statement + + .. note:: + Compilation is necessary because it is the moment where the problem statement and + the FQAOA instructions are used to build the actual FQAOA circuit. + + .. tip:: + Set Verbose to false if you are running batch computations! + + Parameters + ---------- + problem: `QUBO` + portfolio optimisation problems converted to QUBO using penalty methods + n_fermions: `int` + a constraint value, budgets in portfolio optimization problem. + hopping: `float`, optional + the coefficient of the fermionic mixer Hamiltonian + verbose: bool + Set True to have a summary of FQAOA to displayed after compilation + """ + + # connect to the QPU specified + self.device.check_connection() + # we compile the method of the parent class to genereate the id and + # check the problem is a QUBO object and save it + super().compile(problem=problem) + + # check the n_fermions is given and save it + if n_fermions is None: + raise ValueError("In FQAOA, the 'n_fermions' argument must be specified") + + self.n_fermions = n_fermions + self.hopping = hopping + + self.cost_hamil = Hamiltonian.classical_hamiltonian( + terms=problem.terms, coeffs=problem.weights, constant=problem.constant + ) + + self.n_qubits = self.cost_hamil.n_qubits + + # Determine the coefficients of the mixer hamiltonian + if self.circuit_properties.mixer_qubit_connectivity == "cyclic": + self.circuit_properties.mixer_coeffs = [-0.5*hopping] * 2 * self.n_qubits + elif self.circuit_properties.mixer_qubit_connectivity == "chain": + self.circuit_properties.mixer_coeffs = [-0.5*hopping] * 2 * (self.n_qubits-1) + + self.mixer_hamil = get_mixer_hamiltonian( + n_qubits=self.n_qubits, + mixer_type=self.circuit_properties.mixer_hamiltonian, + qubit_connectivity=self.circuit_properties.mixer_qubit_connectivity, + coeffs=self.circuit_properties.mixer_coeffs, + ) + + self.qaoa_descriptor = QAOADescriptor( + self.cost_hamil, + self.mixer_hamil, + p=self.circuit_properties.p, + routing_function=routing_function, + device=self.device, + ) + + self.variate_params = create_qaoa_variational_params( + qaoa_descriptor=self.qaoa_descriptor, + params_type=self.circuit_properties.param_type, + init_type=self.circuit_properties.init_type, + variational_params_dict=self.circuit_properties.variational_params_dict, + linear_ramp_time=self.circuit_properties.linear_ramp_time, + q=self.circuit_properties.q, + seed=self.circuit_properties.seed, + total_annealing_time=self.circuit_properties.annealing_time, + ) + + # Backend configuration required for initial state preparation in FQAOA. + lattice = self.circuit_properties.mixer_qubit_connectivity + + # fermion orbitals + if lattice == "cyclic" and hopping > 0.0: orbitals = get_analytical_fermi_orbitals(self.n_qubits, self.n_fermions, lattice, hopping) + else: orbitals = get_fermi_orbitals(self.n_qubits, self.n_fermions, lattice, hopping) + + # initial statevector or circuit + if self.device.device_name in 'vectorized': + self.backend_properties.prepend_state = get_statevector(orbitals) + else: + gate_applicator = self._gate_applicator() + self.backend_properties.prepend_state = self._fermi_initial_circuit(orbitals, gate_applicator) + + backend_dict = self.backend_properties.__dict__.copy() + + self.backend = get_qaoa_backend( + qaoa_descriptor=self.qaoa_descriptor, + device=self.device, + **backend_dict, + ) + + # Implementing SPAM Twirling and MITIQs error mitigation requires wrapping the backend. + # However, the BaseWrapper can have many more use cases. + if ( + self.error_mitigation_properties.error_mitigation_technique + == "spam_twirling" + ): + self.backend = SPAMTwirlingWrapper( + backend=self.backend, + n_batches=self.error_mitigation_properties.n_batches, + calibration_data_location=self.error_mitigation_properties.calibration_data_location, + ) + elif( + self.error_mitigation_properties.error_mitigation_technique + == "mitiq_zne" + ): + self.backend = ZNEWrapper( + backend=self.backend, + factory=self.error_mitigation_properties.factory, + scaling=self.error_mitigation_properties.scaling, + scale_factors=self.error_mitigation_properties.scale_factors, + order=self.error_mitigation_properties.order, + steps=self.error_mitigation_properties.steps + ) + + self.optimizer = get_optimizer( + vqa_object=self.backend, + variational_params=self.variate_params, + optimizer_dict=self.classical_optimizer.asdict(), + ) + + # Set the header properties + self.header["target"] = self.device.device_name + self.header["cloud"] = self.device.device_location + + metadata = { + "p": self.circuit_properties.p, + "param_type": self.circuit_properties.param_type, + "init_type": self.circuit_properties.init_type, + "optimizer_method": self.classical_optimizer.method, + } + + self.set_exp_tags(tags=metadata) + + self.compiled = True + + if verbose: + print("\t \033[1m ### Summary ###\033[0m") + print("OpenQAOA has been compiled with the following properties") + print( + f"Solving FQAOA with \033[1m {self.device.device_name} \033[0m on" + f"\033[1m{self.device.device_location}\033[0m" + ) + print( + f"Using p={self.circuit_properties.p} with {self.circuit_properties.param_type}" + f"parameters initialized as {self.circuit_properties.init_type}" + ) + + if hasattr(self.backend, "n_shots"): + print( + f"OpenQAOA will optimize using \033[1m{self.classical_optimizer.method}" + f"\033[0m, with up to \033[1m{self.classical_optimizer.maxiter}" + f"\033[0m maximum iterations. Each iteration will contain" + f"\033[1m{self.backend_properties.n_shots} shots\033[0m" + ) + else: + print( + f"OpenQAOA will optimize using \033[1m{self.classical_optimizer.method}\033[0m," + "with up to \033[1m{self.classical_optimizer.maxiter}\033[0m maximum iterations" + ) + + return None + + def optimize(self, verbose=False): + """ + A method running the classical optimisation loop + """ + + if self.compiled is False: + raise ValueError("Please compile the FQAOA before optimizing it !") + + # timestamp for the start of the optimization + self.header["execution_time_start"] = generate_timestamp() + + self.optimizer.optimize() + # TODO: result and qaoa_result will differ + self.result = self.optimizer.qaoa_result + + # timestamp for the end of the optimization + self.header["execution_time_end"] = generate_timestamp() + + if verbose: + print("Optimization completed.") + return + + def evaluate_circuit( + self, + params: Union[List[float], Dict[str, List[float]], QAOAVariationalBaseParams], + ): + """ + A method to evaluate the QAOA circuit at a given set of parameters + + Parameters + ---------- + params: list or dict or QAOAVariationalBaseParams or None + List of parameters or dictionary of parameters. Which will be used to evaluate the QAOA circuit. + If None, the variational parameters of the QAOA object will be used. + + Returns + ------- + result: dict + A dictionary containing the results of the evaluation: + - "cost": the expectation value of the cost Hamiltonian + - "uncertainty": the uncertainty of the expectation value of the cost Hamiltonian + - "measurement_results": either the state of the QAOA circuit output (if the QAOA circuit is + evaluated on a state simulator) or the counts of the QAOA circuit output + (if the QAOA circuit is evaluated on a QPU or shot-based simulator) + """ + # before evaluating the circuit we check that the QAOA object has been compiled + if self.compiled is False: + raise ValueError("Please compile the QAOA before optimizing it!") + + # Check the type of the input parameters and save them as a + # QAOAVariationalBaseParams object at the variable `params_obj` + + # if the parameters are passed as a dictionary we copy and update the variational parameters of the QAOA object + if isinstance(params, dict): + params_obj = deepcopy(self.variate_params) + # we check that the dictionary contains all the parameters of the QAOA object that are not empty + for key, value in params_obj.asdict().items(): + if value.size > 0: + assert ( + key in params.keys() + ), f"The parameter `{key}` is missing from the input dictionary" + params_obj.update_from_dict(params) + + # if the parameters are passed as a list we copy and update the variational parameters of the QAOA object + elif isinstance(params, list) or isinstance(params, np.ndarray): + assert len(params) == len( + self.variate_params + ), "The number of parameters does not match the number of parameters in the QAOA circuit" + params_obj = deepcopy(self.variate_params) + params_obj.update_from_raw(params) + + # if the parameters are passed as a QAOAVariationalBaseParams object we just take it as it is + elif isinstance(params, QAOAVariationalBaseParams): + # check whether the input params object is supported for circuit evaluation + assert ( + len(self.variate_params.mixer_1q_angles) == len(params.mixer_1q_angles) + and len(self.variate_params.mixer_2q_angles) + == len(self.variate_params.mixer_2q_angles) + and len(self.variate_params.cost_1q_angles) + == len(self.variate_params.cost_1q_angles) + and len(self.variate_params.cost_2q_angles) + == len(self.variate_params.cost_2q_angles) + ), "Specify a supported params object" + params_obj = params + + # if the parameters are passed in a different format, we raise an error + else: + raise TypeError( + f"The input params must be a list or a dictionary. Instead, received {type(params)}" + ) + + # Evaluate the QAOA circuit and return the results + output_dict = { + "cost": None, + "uncertainty": None, + "measurement_results": None, + } + # if the workflow implements SPAM Twirling, + # we just return the expectation value of the cost Hamiltonian and the measurement outcomes + if isinstance(self.backend, SPAMTwirlingWrapper): + cost = self.backend.expectation(params_obj) + measurement_results = ( + self.backend.measurement_outcomes + if isinstance(self.backend.measurement_outcomes, dict) + else self.backend.measurement_outcomes.tolist() + ) + output_dict.update( + { + "cost": cost, + "measurement_results": measurement_results, + } + ) + # in all other cases, we return the expectation value of the cost Hamiltonian, + # the associated uncertainty and the measurement outcomes + else: + cost, uncertainty = self.backend.expectation_w_uncertainty(params_obj) + measurement_results = ( + self.backend.measurement_outcomes + if isinstance(self.backend.measurement_outcomes, dict) + else self.backend.measurement_outcomes.tolist() + ) + output_dict.update( + { + "cost": cost, + "uncertainty": uncertainty, + "measurement_results": measurement_results, + } + ) + return output_dict + + def _serializable_dict( + self, complex_to_string: bool = False, intermediate_measurements: bool = True + ): + """ + Returns all values and attributes of the object that we want to return in + `asdict` and `dump(s)` methods in a dictionary. + + Parameters + ---------- + complex_to_string: bool + If True, complex numbers are converted to strings. + This is useful for JSON serialization. + + Returns + ------- + serializable_dict: dict + A dictionary containing all the values and attributes of the object + that we want to return in `asdict` and `dump(s)` methods. + intermediate_measurements: bool + If True, intermediate measurements are included in the dump. + If False, intermediate measurements are not included in the dump. + Default is True. + """ + + # we call the _serializable_dict method of the parent class, + # specifying the keys to delete from the results dictionary + serializable_dict = super()._serializable_dict( + complex_to_string, intermediate_measurements + ) + + # we add the keys of the QAOA object that we want to return + serializable_dict["data"]["input_parameters"]["circuit_properties"] = dict( + self.circuit_properties + ) + + # include parameters in the header metadata + serializable_dict["header"]["metadata"]["param_type"] = serializable_dict[ + "data" + ]["input_parameters"]["circuit_properties"]["param_type"] + serializable_dict["header"]["metadata"]["init_type"] = serializable_dict[ + "data" + ]["input_parameters"]["circuit_properties"]["init_type"] + serializable_dict["header"]["metadata"]["p"] = serializable_dict["data"][ + "input_parameters" + ]["circuit_properties"]["p"] + + if ( + serializable_dict["data"]["input_parameters"]["circuit_properties"]["q"] + is not None + ): + serializable_dict["header"]["metadata"]["q"] = serializable_dict["data"][ + "input_parameters" + ]["circuit_properties"]["q"] + + return serializable_dict + + def _fermi_initial_circuit(self, orbitals: np.array, gate_applicator: object) -> object: + """ + Constructs the initial quantum circuit for the FQAOA. + + This method initializes a quantum circuit for a system with a specified number of fermions and + qubits. The method applies X gates to excite the number of fermions and then applies a series + of Givens rotation gates according to the provided orbital data. + + Parameters + ---------- + orbitals : np.array + A numpy array containing the orbital information needed to compute the Givens rotation angles. + gate_applicator : object + An object responsible for applying quantum gates to the circuit. + + Returns + ------- + object + A quantum circuit object initialized with the fermions and Givens rotations. + """ + + initial_circuit = gate_applicator.create_quantum_circuit(self.n_qubits) + + # excites `n_fermions` number of fermion + for i in range(self.n_fermions): + gate = X(gate_applicator, i) + gate.apply_gate(initial_circuit) + + # appply `givens rotation gate` + gtheta = get_givens_rotation_angle(orbitals) + i = (self.n_qubits-self.n_fermions)*self.n_fermions + for irow in range(self.n_fermions-1, -1, -1): + for icol in range(irow+1, self.n_qubits-self.n_fermions+irow+1): + i -= 1 + angle = gtheta[i] + for each_tuple in GivensRotationGateMap(icol, icol-1, angle).decomposition('standard'): + gate = each_tuple[0](gate_applicator, *each_tuple[1]) + gate.apply_gate(initial_circuit) + + return initial_circuit + + def _gate_applicator(self) -> object: + """ + Set up and return the gate applicator for the specified device. + + This method temporarily sets the backend by calling the appropriate + gate applicator based on the specified device properties. + + Returns + ------- + object + The gate applicator object associated with the specified device. + """ + + device_name = self.device.device_name + backend_dict = self.backend_properties.__dict__.copy() + self.backend = get_qaoa_backend( + qaoa_descriptor=self.qaoa_descriptor, + device = self.device, + **backend_dict,) + gate_applicator = self.backend.gate_applicator + + return(gate_applicator) + +class GivensRotationGateMap(GateMap): + """ + Returns the gate applicator object for the specified quantum backend. + + This method configures the quantum backend based on the device. + It then retrieves and returns the gate applicator, which is used to apply quantum gates in the + circuit construction process. + + Returns + ------- + object + An object representing the gate applicator for the current backend. + """ + + def __init__(self, qubit_1: int, qubit_2: int, angle: float): + super().__init__(qubit_1) + self.qubit_2 = qubit_2 + self.angle = angle + self.gate_label = GateMapLabel(n_qubits=2, gatemap_type=GateMapType.FIXED) + + @property + def _decomposition_standard(self) -> List[Tuple]: + givens_rotation = [] + givens_rotation.append((RZ, [self.qubit_2, RotationAngle(lambda x: x, self.gate_label, np.pi / 2)])) + givens_rotation.append((RZ, [self.qubit_1, RotationAngle(lambda x: x, self.gate_label, np.pi / 2)])) + givens_rotation.append((RY, [self.qubit_1, RotationAngle(lambda x: x, self.gate_label, np.pi / 2)])) + givens_rotation.append((X, [self.qubit_1])) + givens_rotation.append((CX, [self.qubit_1, self.qubit_2])) + givens_rotation.append((RY, [self.qubit_2, RotationAngle(lambda x: x, self.gate_label, self.angle)])) + givens_rotation.append((RY, [self.qubit_1, RotationAngle(lambda x: x, self.gate_label, self.angle)])) + givens_rotation.append((CX, [self.qubit_1, self.qubit_2])) + givens_rotation.append((RY, [self.qubit_1, RotationAngle(lambda x: x, self.gate_label, np.pi / 2)])) + givens_rotation.append((X, [self.qubit_1])) + givens_rotation.append((RZ, [self.qubit_2, RotationAngle(lambda x: x, self.gate_label, -np.pi / 2)])) + givens_rotation.append((RZ, [self.qubit_1, RotationAngle(lambda x: x, self.gate_label, -np.pi / 2)])) + + return givens_rotation + +class FermiBackendProperties(WorkflowProperties): + """ + Choose the backend on which to run the QAOA circuits + + Parameters + ---------- + device: DeviceBase + The device to use for the backend. + prepend_state: Union[openqaoa.basebackend.QuantumCircuitBase,numpy.ndarray(complex)] + The state prepended to the circuit. + append_state: Union[QuantumCircuitBase,numpy.ndarray(complex)] + The state appended to the circuit. + init_hadamard: bool + Whether to apply a Hadamard gate to the beginning of the + QAOA part of the circuit. + n_shots: int + The number of shots to be used for the shot-based computation. + cvar_alpha: float + The value of the CVaR parameter. + noise_model: NoiseModel + The `qiskit` noise model to be used for the shot-based simulator. + initial_qubit_mapping: Union[List[int], numpy.ndarray] + Mapping from physical to logical qubit indices, used to eventually + construct the quantum circuit. For example, for a system composed by 3 qubits + `qubit_layout=[1,3,2]`, maps `1<->0`, `3<->1`, `2<->2`, where the left hand side is the physical qubit + and the right hand side is the logical qubits + qiskit_simulation_method: str + Specify the simulation method to use with the `qiskit.AerSimulator` + qiskit_optimization_level: int, optional + Specify the qiskit.transpile optimization level. Choose from 0,1,2,3 + seed_simulator: int + Specify a seed for `qiskit` simulators + active_reset: bool + To use the active_reset functionality on Rigetti backends through QCS + rewiring: str + Specify the rewiring strategy for compilation for Rigetti QPUs through QCS + disable_qubit_rewiring: bool + enable/disbale qubit rewiring when accessing QPUs via the AWS `braket` + """ + + def __init__( + self, + prepend_state: Optional[ + Union[QuantumCircuitBase, List[complex], np.ndarray] + ] = None, + append_state: Optional[ + Union[QuantumCircuitBase, np.ndarray] + ] = None, + init_hadamard: bool = False, + n_shots: int = 100, + cvar_alpha: float = 1, + noise_model=None, + initial_qubit_mapping: Optional[Union[List[int], np.ndarray]] = None, + qiskit_simulation_method: Optional[str] = None, + qiskit_optimization_level: Optional[int] = None, + seed_simulator: Optional[int] = None, + active_reset: Optional[bool] = None, + rewiring: Optional[str] = None, + disable_qubit_rewiring: Optional[bool] = None, + ): + if init_hadamard: + raise ValueError("In FQAOA, init_hadamard is not recognised.") + if prepend_state is not None: + raise ValueError("In FQAOA, prepend_state is not recognised.") + if append_state is not None: + raise ValueError("In FQAOA, append_state is not recognised.") + self.init_hadamard = False + self.prepend_state = None + self.append_state = None + self.n_shots = n_shots + self.cvar_alpha = cvar_alpha + self.noise_model = noise_model + self.initial_qubit_mapping = initial_qubit_mapping + self.seed_simulator = seed_simulator + self.qiskit_simulation_method = qiskit_simulation_method + self.qiskit_optimization_level = qiskit_optimization_level + self.active_reset = active_reset + self.rewiring = rewiring + self.disable_qubit_rewiring = disable_qubit_rewiring + +class FermiCircuitProperties(WorkflowProperties): + """ + Tunable properties of the FQAOA circuit to be specified by the user + + The only difference with CircuitProperties is that mixer_hamiltonian is limited to "xy" + and mixer_qubit connetivity is limited to "cyclic" or "chain". + """ + + def __init__( + self, + param_type: str = "standard", + init_type: str = "ramp", + qubit_register: List = [], + p: int = 1, + q: Optional[int] = 1, + annealing_time: Optional[float] = None, + linear_ramp_time: Optional[float] = None, + variational_params_dict: Optional[dict] = {}, + mixer_hamiltonian: Optional[str] = "xy", + mixer_qubit_connectivity: Optional[str] = "cyclic", + mixer_coeffs: Optional[float] = None, + seed: Optional[int] = None, + ): + self.param_type = param_type + self.init_type = init_type + self.qubit_register = qubit_register + self.p = p + self.q = ( + q + if param_type.lower() in ["fourier", "fourier_extended", "fourier_w_bias"] + else None + ) + self.variational_params_dict = variational_params_dict + self.annealing_time = ( + annealing_time if annealing_time is not None else 0.7 * self.p + ) + self.linear_ramp_time = ( + linear_ramp_time if linear_ramp_time is not None else 0.7 * self.p + ) + if mixer_hamiltonian.lower() not in ALLOWED_MIXERS: + raise ValueError(f"In FQAOA, mixer_hamiltonian {mixer_hamiltonian.lower()} is not recognised. Please use {ALLOWED_MIXERS}") + if mixer_qubit_connectivity not in ALLOWED_LATTICE: + raise ValueError(f"In FQAOA, mixer_qubit_connectivity {mixer_qubit_connectivity} is not recognised. Please use {ALLOWED_LATTICE}") + self.mixer_hamiltonian = mixer_hamiltonian + self.mixer_qubit_connectivity = mixer_qubit_connectivity + self.mixer_coeffs = mixer_coeffs + self.seed = seed + + @property + def param_type(self): + return self._param_type + + @param_type.setter + def param_type(self, value): + if value not in ALLOWED_PARAM_TYPES: + raise ValueError( + f"param_type {value} is not recognised. Please use {ALLOWED_PARAM_TYPES}" + ) + self._param_type = value + + @property + def init_type(self): + return self._init_type + + @init_type.setter + def init_type(self, value): + if value not in ALLOWED_INIT_TYPES: + raise ValueError( + f"init_type {value} is not recognised. Please use {ALLOWED_INIT_TYPES}" + ) + self._init_type = value + + @property + def mixer_hamiltonian(self): + return self._mixer_hamiltonian + + @mixer_hamiltonian.setter + def mixer_hamiltonian(self, value): + if value not in ALLOWED_MIXERS: + raise ValueError( + f"mixer_hamiltonian {value} is not recognised. Please use {ALLOWED_MIXERS}" + ) + self._mixer_hamiltonian = value + + @property + def p(self): + return self._p + + @p.setter + def p(self, value): + if value <= 0: + raise ValueError( + f"Number of layers `p` cannot be smaller or equal to zero. Value {value} was provided" + ) + self._p = value + + @property + def annealing_time(self): + return self._annealing_time + + @annealing_time.setter + def annealing_time(self, value): + if value <= 0: + raise ValueError( + f"The annealing time `annealing_time` cannot be smaller or equal to zero. Value {value} was provided" + ) + self._annealing_time = value From 6f046f41dd7c27a741e7851016910b4e52d21277 Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Fri, 23 Aug 2024 12:54:32 +0900 Subject: [PATCH 03/26] Add fqaoa_utils.py --- .../openqaoa/algorithms/fqaoa/fqaoa_utils.py | 402 ++++++++++++++++++ 1 file changed, 402 insertions(+) create mode 100644 src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py diff --git a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py new file mode 100644 index 000000000..fe50f08f4 --- /dev/null +++ b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py @@ -0,0 +1,402 @@ +from typing import List, Optional, Tuple +from itertools import combinations +from scipy import linalg +import numpy as np + +ALLOWED_LATTICE = ["cyclic", "chain"] + +def get_givens_rotation_angle(orbitals: np.array) -> List[float]: + """ + Compute the Givens rotation angles for transforming the orbital matrix `orbitals`. + + The function calculates the Givens rotation angles required to convert + the input orbitals matrix `orbitals` to a left-aligned diagonal matrix. + The angles are calculated based on the matrix entries and are returned + as a list of angles in radians. + + Parameters + ---------- + orbitals : np.array + A 2D NumPy array representing the matrix of orbitals. The matrix should have a shape of + (n_fermions, n_qubits), where `n_fermions` is the number of rows and `n_qubits` is + the number of columns. + + Returns + ------- + list of float + A list of Givens rotation angles in radians. + + Raises + ------ + ValueError + If the number of rows (n_fermions) is greater than the number of columns (n_qubits). + + Notes + ----- + The function modifies the `orbitals` matrix in-place during the calculation of the + Givens rotation angles. + """ + + n_fermions, n_qubits = orbitals.shape + + if n_fermions > n_qubits: + raise ValueError(f"n_fermions ({n_fermions}) cannot be greater than n_qubits ({n_qubits}).") + + # perform unitary transformations to reduce the number of Givens rotation operations + orbitals = _unitary_sparsification(orbitals) + + # Calculate the Givens rotation angles + gtheta = [] + for irow in range(n_fermions): + for icol in range(n_qubits - n_fermions + irow, irow, -1): + if orbitals[irow][icol - 1] != 0.0: + rate = orbitals[irow][icol] / orbitals[irow][icol - 1] + uk = 1.0 / np.sqrt(1 + rate ** 2) + vk = -rate / np.sqrt(1 + rate ** 2) + angle = np.arccos(uk) if vk >= 0 else -np.arccos(uk) + else: + angle = np.pi/2.0 + gtheta.append(angle) + + # Apply the computed rotation angle to the matrix + for ik in range(n_fermions): + temp = orbitals[ik][icol - 1] + orbitals[ik][icol - 1] = temp * np.cos(angle) - orbitals[ik][icol] * np.sin(angle) + orbitals[ik][icol] = temp * np.sin(angle) + orbitals[ik][icol] * np.cos(angle) + + return gtheta + +def get_statevector(orbitals: np.array) -> np.ndarray: + """ + Compute the statevector from fermionic orbitals. + + Parameters + ---------- + orbitals : np.array + A 2D NumPy array representing the matrix of orbitals. The matrix should have a shape of + (n_fermions, n_qubits), where `n_fermions` is the number of rows and `n_qubits` is + the number of columns. + + Returns + ------- + numpy.ndarray + A 1D NumPy array of complex numbers representing the statevector of the quantum system. + The length of this array is `2**n_qubits`, corresponding to all possible basis states. + + Raises + ------ + ValueError + If the number of rows (n_fermions) is greater than the number of columns (n_qubits). + + Notes + ----- + The statevector is calculated by iterating over all possible combinations of `n_fermions` + occupied orbitals and computing the determinant of the corresponding submatrix of `orbitals`. + """ + + n_fermions, n_qubits = orbitals.shape + + if n_fermions > n_qubits: + raise ValueError(f"n_fermions ({n_fermions}) cannot be greater than n_qubits ({n_qubits}).") + + statevector = np.zeros(2**n_qubits, dtype = np.complex128) + cof = np.zeros((n_fermions, n_fermions), dtype = np.complex128) + # Generate all combinations of bit positions with the number of fermions being 1 + for bits in combinations(range(n_qubits), n_fermions): + indices = list(bits) + inum = sum(1 << i for i in indices) + # Update the cof matrix based on the current combination of bit positions + for i, j in enumerate(indices): + cof[:, i] = orbitals[:, j] + # Calculate the determinant and store it in the statevector + statevector[inum] = np.linalg.det(cof) + + return statevector + +def get_analytical_fermi_orbitals( + n_qubits: int, + n_fermions: int, + lattice: str, + hopping: float, +) -> np.ndarray: + """ + Compute fermionic orbitals from the analytical solution. + + This function computes a matrix representing fermionic orbitals based on an analytical + solution for a free fermions on a cyclic lattice. + The specific orbitals are found in Eq. (11) of T. Yoshoka et al. arXiv:2312.04710v1 [quant-ph]. + + Parameters + ---------- + n_qubits : int + The number of qubits, which determines the size of the system. + n_fermions : int + The number of fermions, which determines how many rows of the + orbital matrix are considered in the computation. + lattice : str + The type of lattice configuration. Currently, only 'cyclic' lattice configurations + are supported. + hopping : float + The hopping parameter, which must be greater than 0. This value represents + the amplitude of hopping between lattice sites. + + Returns + ------- + np.ndarray + A 2D NumPy array of shape (n_fermions, n_qubits) representing the fermionic orbitals. + + Raises + ------ + ValueError + If `n_fermions` is greater than `n_qubits`. + ValueError + If the `lattice` is not 'cyclic'. + ValueError + If `hopping` is less than or equal to 0. + + Notes + ----- + The orbitals computed by this function are based on the analytical solutions described in: + - Eq. (11) in arXiv:2312.04710v1 [quant-ph], https://arxiv.org/pdf/2312.04710 + + The function currently only supports systems with a cyclic lattice configuration. + """ + + if n_fermions > n_qubits: + raise ValueError(f"n_fermions ({n_fermions}) cannot be greater than n_qubits ({n_qubits}).") + + if lattice not in 'cyclic': + raise ValueError("analytical solutions support only 'cyclic'") + + if hopping <= 0.0: raise ValueError("analytical solutions support hopping > 0") + + orbitals = np.zeros((n_fermions, n_qubits), dtype = np.float64) + if n_fermions % 2 == 0: + for jw in range(n_qubits): + for k in range(int(n_fermions/2.0)): + k2 = k + int((n_fermions)/2.0) + angle = jw * 2.0 * np.pi * ((k+0.5) / n_qubits) + orbitals[ k][jw] = np.sin( angle) * np.sqrt(2.0/n_qubits) + orbitals[k2][jw] = np.cos(-angle) * np.sqrt(2.0/n_qubits) + else: + for jw in range(n_qubits): + orbitals[0][jw] = np.sqrt(1.0/n_qubits) + for k in range(int((n_fermions-1)/2.0)): + k2 = k + int((n_fermions-1)/2.0) + angle = jw * 2.0 * np.pi * ((k+1) / n_qubits) + orbitals[ k+1][jw] = np.sin( angle) * np.sqrt(2.0/n_qubits) + orbitals[k2+1][jw] = np.cos(-angle) * np.sqrt(2.0/n_qubits) + + return orbitals + +def get_fermi_orbitals( + n_qubits: int, + n_fermions: int, + lattice: str, + hopping: float +) -> np.ndarray: + """ + Compute fermionic orbitals from the Hamiltonian eigenvectors. + + This function generates a matrix representing fermionic orbitals by computing the eigenvectors + of a given fermionic mixer Hamiltonian. + + Parameters + ---------- + n_qubits : int + The number of qubits, which corresponds to the number of sites or modes in the system. + n_fermions : int + The number of fermions, which determines the number of occupied states in the system. + lattice : str + The type of lattice configuration. Only specific lattice types defined in `cyclic` and `chain` + are supported. + hopping : float + The hopping parameter, which defines the amplitude of hopping between adjacent lattice sites. + It must be non-zero. + + Returns + ------- + np.ndarray + A 2D NumPy array of shape (n_fermions, n_qubits) representing the fermionic orbitals. + Each row corresponds to an orbital and each column corresponds to a qubit (site). + + Raises + ------ + ValueError + If `n_fermions` is greater than `n_qubits`. + ValueError + If the `lattice` type is not recognized (i.e., not in [`cyclic`, `chain`]). + ValueError + If `hopping` is zero. + + Returns + ------- + numpy.ndarray + matrix representation of Fermionic orbitals. + + Notes + ----- + The orbitals are derived from the eigenvectors of the Hamiltonian corresponding to the given + system parameters. The specific eigenvector calculation is handled by the `_get_free_eigen` + function, which depends on the system's configuration. + """ + + if n_fermions > n_qubits: + raise ValueError(f"n_fermions ({n_fermions}) cannot be greater than n_qubits ({n_qubits}).") + + if lattice not in ALLOWED_LATTICE: + raise ValueError(f"In FQAOA, lattice {lattice} is not recognised. Please use {ALLOWED_LATTICE}") + + if hopping == 0.0: raise ValueError("In FQAOA, hopping = 0 is not recgnized. Please use hopping != 0") + + orbitals = np.zeros((n_fermions, n_qubits), dtype = np.float64) + eig = _get_free_eigen(n_qubits, n_fermions, lattice, hopping) + for jw in range(n_qubits): + for k in range(n_fermions): + orbitals[k][jw] = eig[jw][k] + + return orbitals + +def generate_random_portfolio_data( + num_assets: int, + num_days: int, + seed: Optional[int] = None, +) -> Tuple[List[float], List[List[float]], np.ndarray]: + """ + Generates random portfolio data including mean returns, covariance matrix, + and historical price movements for a given number of assets and days. + + Parameters + ---------- + num_assets : int + The number of assets in the portfolio. + num_days : int + The number of days over which the historical data is generated. + seed : Optional[int], optional + An optional random seed for reproducibility, by default None. + + Returns + ------- + mu : List[float] + The mean returns for each asset. + sigma : List[List[float]] + The covariance matrix of the asset returns. + hist_exp : np.ndarray + The generated historical price movements for the assets. + + Notes + ----- + The function simulates historical price movements by generating random data + influenced by a time trend and random fluctuations, suitable for use in + portfolio optimization and risk analysis. + """ + + # If a seed is provided, set the random seed + if seed is not None: + np.random.seed(seed) + + # Generate historical-like data for multiple assets over a number of days + random_asset_factors = (1 - 2 * np.random.rand(num_assets)).reshape(-1, 1) + day_indices = np.array([np.arange(num_days) for i in range(num_assets)]) + np.random.randint(10) + random_fluctuations = 1 - 2 * np.random.rand(num_assets, num_days) + + # The resulting matrix hist_exp represents the daily returns or price levels of the assets + hist_exp = random_asset_factors * day_indices + random_fluctuations + + # Calculate the mean returns (mu) for each asset + # and the covariance matrix (sigma) of the asset returns + mu = hist_exp.mean(axis=1).tolist() + sigma = np.cov(hist_exp).tolist() + + return mu, sigma, hist_exp + +def _get_free_eigen( + n_qubits: int, + n_fermions: int, + lattice: str, + hopping: float, +) -> np.ndarray: + """ + Compute the eigenvectors of the fermionic mixer Hamiltonian for a given lattice and hopping parameter. + + This function constructs the Hamiltonian for a system with a specified number of qubits + and fermions, based on the lattice configuration and hopping amplitude. It then computes the + eigenvectors of this Hamiltonian matrix. + + Parameters + ---------- + n_qubits : int + The number of qubits, corresponding to the size of the Hamiltonian matrix (n_qubits x n_qubits). + n_fermions : int + The number of fermions in the system, which affects the phase of the cyclic boundary condition + if the lattice is cyclic. + lattice : str + The type of lattice configuration. Currently, only 'cyclic' is supported. + hopping : float + The hopping parameter that scales the Hamiltonian matrix elements. It defines the amplitude + of hopping between adjacent lattice sites. + + Returns + ------- + np.ndarray + A 2D NumPy array of shape (n_qubits, n_qubits) containing the eigenvectors of the Hamiltonian matrix. + Each column of the array represents an eigenvector. + + Notes + ----- + The Hamiltonian matrix is constructed with nearest-neighbor interactions and optional cyclic boundary + conditions, depending on the lattice type. The eigenvectors are computed using `scipy.linalg.eigh`, + which returns them in columns. + """ + + fermi_hamiltonian = np.zeros((n_qubits, n_qubits), dtype = np.float64) + for jw in range(1, n_qubits): + fermi_hamiltonian[jw, jw-1] = -1.0 + if lattice == 'cyclic': + fermi_hamiltonian[n_qubits-1, 0] = (-1.0)**n_fermions + fermi_hamiltonian = fermi_hamiltonian*hopping + eig = linalg.eigh(fermi_hamiltonian) + + return eig[1] + +def _unitary_sparsification(orbitals: np.array) -> np.ndarray: + """ + Perform a unitary transformation to sparsify a matrix `orbitals` + by setting the elements in the upper triangular region to zero. + + This method applies a series of Givens rotations to eliminate the upper + triangular elements of the input matrix `orbitals`. The transformation is + carried out in-place, modifying `orbitals` directly. + + Parameters + ---------- + orbitals : numpy.ndarray + A 2D NumPy array representing the non-square matrix to be transformed. + The matrix shape is expected to be `(n_fermions, n_qubits)` where + `n_fermions <= n_qubits`. + + Returns + ------- + numpy.ndarray + The modified matrix `orbitals` with its upper triangular elements set to zero. + """ + + n_fermions, n_qubits = orbitals.shape + + for it in range(n_fermions - 1): + icol = n_qubits - 1 - it + for irot in range(n_fermions - 1 - it): + if orbitals[irot + 1][icol] == 0.0: + # Swap rows if necessary + orbitals[irot], orbitals[irot + 1] = orbitals[irot + 1], orbitals[irot] + else: + # Apply Givens rotation + rate = orbitals[irot][icol] / orbitals[irot + 1][icol] + factor = np.sqrt(1 + rate ** 2) + for jw in range(n_qubits): + orbitals[irot][jw], orbitals[irot + 1][jw] = ( + (orbitals[irot][jw] - rate * orbitals[irot + 1][jw]) / factor, + (orbitals[irot + 1][jw] + rate * orbitals[irot][jw]) / factor, + ) + + return orbitals From c62d3dcdf4c926494d842fc3964cc9d0a45c519f Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Fri, 23 Aug 2024 12:55:56 +0900 Subject: [PATCH 04/26] Add test_fqaoa.py and ensure all tests pass --- src/openqaoa-core/tests/test_fqaoa.py | 253 ++++++++++++++++++++++++++ 1 file changed, 253 insertions(+) create mode 100644 src/openqaoa-core/tests/test_fqaoa.py diff --git a/src/openqaoa-core/tests/test_fqaoa.py b/src/openqaoa-core/tests/test_fqaoa.py new file mode 100644 index 000000000..5e0b748f6 --- /dev/null +++ b/src/openqaoa-core/tests/test_fqaoa.py @@ -0,0 +1,253 @@ +import unittest +import copy +import numpy as np + +from openqaoa.algorithms.fqaoa.fqaoa_utils import ( + get_analytical_fermi_orbitals, + get_fermi_orbitals, + get_givens_rotation_angle, + get_statevector, + generate_random_portfolio_data, +) + +""" +Unittest based testing of current implementation of the FQAOA Algorithm +""" + +class TestFQAOAUtils(unittest.TestCase): + + def setUp(self): + self.valid_params = [ + {"n_qubits": 5, "n_fermions": 3, "lattice": "cyclic", "hopping": 1.0}, # cyclic lattice with hopping > 0 and odd n_femrimons + {"n_qubits": 5, "n_fermions": 3, "lattice": "cyclic", "hopping": -1.0}, # cyclic lattice with hopping < 0 and odd n_femrimons + {"n_qubits": 5, "n_fermions": 2, "lattice": "cyclic", "hopping": 1.0}, # cyclic lattice with hopping > 0 and even n_femrimons + {"n_qubits": 5, "n_fermions": 2, "lattice": "cyclic", "hopping": -1.0}, # cyclic lattice with hopping < 0 and even n_femrimons + {"n_qubits": 5, "n_fermions": 3, "lattice": "chain", "hopping": 1.0}, # chain lattice with hopping > 0 and odd n_femrimons + {"n_qubits": 5, "n_fermions": 3, "lattice": "chain", "hopping": -1.0}, # chain lattice with hopping < 0 and odd n_femrimons + {"n_qubits": 5, "n_fermions": 2, "lattice": "chain", "hopping": 1.0}, # chain lattice with hopping > 0 and even n_femrimons + {"n_qubits": 5, "n_fermions": 2, "lattice": "chain", "hopping": -1.0}, # chain lattice with hopping < 0 and even n_femrimons + ] + + self.invalid_params = [ + {"n_qubits": 5, "n_fermions": 2, "lattice": "cyclic", "hopping": 0.0}, # hopping: 0.0 + {"n_qubits": 5, "n_fermions": 2, "lattice": "cyclic", "hopping": 0.0}, # hopping: 0.0 + {"n_qubits": 3, "n_fermions": 5, "lattice": "cyclic", "hopping": 1.0}, # n_fermions > n_qubits + {"n_qubits": 3, "n_fermions": 5, "lattice": "chain", "hopping": 1.0}, # n_fermions > n_qubits + {"n_qubits": 5, "n_fermions": 2, "lattice": "star", "hopping": 1.0}, # unsupported lattice + {"n_qubits": 5, "n_fermions": 2, "lattice": "full", "hopping": 1.0}, # unsupported lattice + ] + + def test_fermi_orbitals_equivalence_to_statevector(self): + """ + Test that get_analytical_fermi_oribalts and get_fermi_orbitals are equivalent by outputting statevector. + + The test consists of generating analytical and numerical free fermi orbitals + and checking that the respective state vectors are numerically consistent. + """ + + for n_qubits, n_fermions, lattice, hopping in [ + (5, 3, "cyclic", 1.0), + (5, 2, "cyclic", 1.0) + ]: + try: + orbitals1 = get_analytical_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) + except ValueError as e: + self.fail(f"Unexpected exception raised: {e}") + + try: + orbitals2 = get_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) + except ValueError as e: + self.fail(f"Unexpected exception raised: {e}") + + statevector = [] + for orbitals in [orbitals1, orbitals2]: + statevector.append(get_statevector(orbitals)) + # Check statevector[0] = e^(i*theta) * statevector[1]. + self.assertTrue(self.is_close_statevector(statevector), "Statevectors are not equivalent up to a global phase.") + + def test_gicvens_rotation_angle_length(self): + """ + Test with various valid inputs for get_givens_rotation_angle. + + This test consists of checking that the fermi orbit is diagonalised, + and the length of the givens rotation angle generated by this diagonalisation. + """ + + for params in self.valid_params: + n_qubits = params["n_qubits"] + n_fermions = params["n_fermions"] + lattice = params["lattice"] + hopping = params["hopping"] + + if lattice == "cyclic" and hopping > 0.0: orbitals = get_analytical_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) + else: orbitals = get_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) + + try: + gtheta = get_givens_rotation_angle(orbitals) + except ValueError as e: + self.fail(f"Unexpected exception raised: {e}") + + # Check the diagonal matrix + self.assertTrue(self.is_left_aligned_diagonal_matrix(orbitals), "orbitals are not diagonalized") + + # Check the length of the returned angles + expected_length = n_fermions * (n_qubits - n_fermions) + self.assertEqual(len(gtheta), expected_length, "Incorrect number of Givens rotation angles") + + def test_givens_rotation_to_statevector(self): + """ + Test get_givens_rotation_angle by outputting statevector. + + The test consists of generating a givens rotation angle by diagonalising the Fermi orbitals + and confirming that the original Fermi orbit is recovered by applying a givens inverse rotation to the diagonalised Fermi orbit. + """ + + for params in self.valid_params: + n_qubits = params["n_qubits"] + n_fermions = params["n_fermions"] + lattice = params["lattice"] + hopping = params["hopping"] + + if lattice == "cyclic" and hopping > 0.0: orbitals0 = get_analytical_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) + else: orbitals0 = get_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) + + orbitals1 = copy.deepcopy(orbitals0) + gtheta = get_givens_rotation_angle(orbitals1) + + # Set an localized n_fermions state. + matrix = np.zeros((n_fermions, n_qubits), dtype=float) + for i in range(min(n_fermions, n_qubits)): + matrix[i, i] = 1 + + # perform givens rotations + it = (n_qubits-n_fermions)*n_fermions + for irow in range(n_fermions-1, -1, -1): + for icol in range(irow+1, n_qubits-n_fermions+irow+1): + it = it-1 + angle = gtheta[it] + for ik in range(n_fermions): + temp = matrix[ik][icol - 1] + matrix[ik][icol - 1] = temp * np.cos(-angle) - matrix[ik][icol] * np.sin(-angle) + matrix[ik][icol] = temp * np.sin(-angle) + matrix[ik][icol] * np.cos(-angle) + statevector = [] + for i, orbitals in enumerate([orbitals0, matrix]): + + try: + statevector.append(get_statevector(orbitals)) + except ValueError as e: + self.fail(f"Unexpected exception raised: {e}") + + # Check statevector[0] = e^(i*theta) * statevector[1]. + self.assertTrue(self.is_close_statevector(statevector), "statevectors are incorrect") + + # exception handling + def test_fermi_analytical_orbital_invalid_input(self): + """Test with various invalid inputs for get_fermi_analytical_orbitals.""" + + for n_qubits, n_fermions, lattice, hopping in [ + (3, 5, "cyclic", 1.0), # n_fermions > n_qubits + (5, 3, "cyclic", -1.0), # hopping < 0.0 + (5, 3, "cyclic", 0.0), # hopping = 0.0 + ]: + with self.assertRaises(ValueError): + get_analytical_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) + + def test_fermi_orbital_invalid_input(self): + """Test with various invalid inputs for get_fermi_orbitals.""" + + for params in self.invalid_params: + n_qubits = params["n_qubits"] + n_fermions = params["n_fermions"] + lattice = params["lattice"] + hopping = params["hopping"] + + with self.assertRaises(ValueError): + get_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) + + def test_generate_portfolio_data_shapes(self): + """Test that the function returns outputs with correct shapes.""" + num_assets, num_days = 10, 15 + # Generate data with the seed + seed = 1 + mu, sigma, hist_exp = generate_random_portfolio_data(num_assets, num_days, seed) + + # Check the shape + self.assertEqual(len(mu), num_assets) + self.assertEqual(len(sigma), num_assets) + self.assertEqual(len(sigma[0]), num_assets) + self.assertEqual(hist_exp.shape, (num_assets, num_days)) + + def test_generate_portfolio_data_without_seed(self): + """Test that setting a seed produces the same output.""" + num_assets, num_days = 10, 15 + # Generate data without the seed + mu1, sigma1, hist_exp1 = generate_random_portfolio_data(num_assets, num_days) + mu2, sigma2, hist_exp2 = generate_random_portfolio_data(num_assets, num_days) + + # Check that the two runs produce different results + self.assertNotEqual(mu1, mu2) + self.assertNotEqual(sigma1, sigma2) + self.assertFalse(np.array_equal(hist_exp1, hist_exp2)) + + @staticmethod + def is_close_statevector(statevector) -> bool: + """ + Checks if statevector[0] can be expressed as e^(i*theta) * statevector[1]. + """ + + # Threshold for considering a value to be zero + tolerance = 1e-10 + + # Check if statevector[0] is approximately zero where statevector[1] is approximately zero + zero_mask_1 = np.isclose(statevector[1], 0, atol=tolerance) + zero_mask_0 = np.isclose(statevector[0], 0, atol=tolerance) + + if np.all(zero_mask_1 == zero_mask_0): + # Create a mask to avoid division by zero + non_zero_mask = ~np.isclose(statevector[1], 0, atol=tolerance) + + # Compute the ratio with the mask applied + ratio = statevector[0][non_zero_mask] / statevector[1][non_zero_mask] + + # Verify if all ratios have the same phase angle + theta_calculated = np.angle(ratio) + theta_adjusted = (theta_calculated + np.pi) % (2 * np.pi) - np.pi + + # Check if the phase difference is consistent + consistent_phase = np.allclose(theta_adjusted, theta_adjusted[0]) + + if consistent_phase: + theta = theta_adjusted[0] + print(f"statevector[0] can be expressed as e^(i*theta) * statevector[1] with theta={theta}.") + return True + print("statevector[0] cannot be expressed as e^(i*theta) * statevector[1].") + print('theta_adjusted', theta_adjusted) + return False + print("It cannot be confirmed that statevector[0] is approximately zero when statevector[1] is approximately zero.") + for i in range(len(statevector[0])): + print(statevector[0][i], statevector[1][i]) + return False + + @staticmethod + def is_left_aligned_diagonal_matrix(matrix: np.ndarray) -> bool: + """ + Checks if the matrix has the most left-aligned diagonal elements as either 1 or -1, + and all other elements as 0. + """ + + np.set_printoptions(precision=3, suppress=True, linewidth=100) + print('fermi orbitals diagonalized by givens rotations') + + rows, cols = matrix.shape + for i in range(rows): + for j in range(cols): + if i == j: # For diagonal elements + if not np.isclose(abs(matrix[i, j]), 1): + return False + else: # For non-diagonal elements + if not np.isclose(matrix[i, j], 0): + return False + return True + +if __name__ == '__main__': + unittest.main() From 46af746b24c99fab1653e52f30af520080ae980f Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Fri, 23 Aug 2024 12:56:34 +0900 Subject: [PATCH 05/26] Add test_analytical_simulator.py and ensure all tests pass --- .../tests/test_analytical_simulator.py | 24 ++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/src/openqaoa-core/tests/test_analytical_simulator.py b/src/openqaoa-core/tests/test_analytical_simulator.py index f990653c8..7cf429178 100644 --- a/src/openqaoa-core/tests/test_analytical_simulator.py +++ b/src/openqaoa-core/tests/test_analytical_simulator.py @@ -2,7 +2,7 @@ import numpy as np from openqaoa.backends.qaoa_analytical_sim import QAOABackendAnalyticalSimulator -from openqaoa.algorithms import QAOA, RQAOA +from openqaoa.algorithms import QAOA, RQAOA, FQAOA from openqaoa.problems import MaximumCut from openqaoa.backends.qaoa_device import create_device from openqaoa.utilities import ( @@ -185,6 +185,28 @@ def test_end_to_end_rqaoa(self): assert opt_solution_string == "01011010" + def test_fqaoa_raises_value_error_with_analytical_simulator(self): + """ + Test to ensure that initializing FQAOA with the 'analytical_simulator' + raises a ValueError. + """ + # Create a 3-regular weighted graph and a qubo problem + g = random_k_regular_graph( + degree=3, nodes=range(8), seed=2642, weighted=True, biases=False + ) + maxcut_qubo = MaximumCut(g).qubo + + # Define the device to be the analytical simulator + device = create_device(location="local", name="analytical_simulator") + + # Define the FQAOA object and set its params + with self.assertRaises(ValueError): + fqaoa = FQAOA(device) + + with self.assertRaises(ValueError): + fqaoa = FQAOA() + fqaoa.set_device(device) + def test_exact_solution(self): """ Testing the exact solution which is a property of every backend. From 8eebd64a7e0da7fcf805671dd82b20c0c1536a63 Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Fri, 23 Aug 2024 12:56:58 +0900 Subject: [PATCH 06/26] Add test_workflows.py and ensure all tests pass --- src/openqaoa-core/tests/test_workflows.py | 634 ++++++++++++++++++++++ 1 file changed, 634 insertions(+) diff --git a/src/openqaoa-core/tests/test_workflows.py b/src/openqaoa-core/tests/test_workflows.py index 661a5cab1..59602eee6 100644 --- a/src/openqaoa-core/tests/test_workflows.py +++ b/src/openqaoa-core/tests/test_workflows.py @@ -1726,6 +1726,640 @@ def test_change_properties_after_compilation(self): with self.assertRaises(ValueError): r.set_rqaoa_parameters(rqaoa_type="adaptive", n_cutoff=3, n_steps=3) +class TestingFQAOA(unittest.TestCase): + """ + Unit test based testing of the QAOA workflow class + """ + + def test_vanilla_qaoa_default_values(self): + fqaoa = FQAOA() + assert fqaoa.circuit_properties.p == 1 + assert fqaoa.circuit_properties.param_type == "standard" + assert fqaoa.circuit_properties.init_type == "ramp" + assert fqaoa.circuit_properties.mixer_hamiltonian == "xy" + assert fqaoa.circuit_properties.mixer_qubit_connectivity == "cyclic" + assert fqaoa.device.device_location == "local" + assert fqaoa.device.device_name == "vectorized" + + def test_end_to_end_vectorized(self): + num_assets, budget = 5, 3 + mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) + po = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo + + fqaoa = FQAOA() + fqaoa.set_classical_optimizer(optimization_progress=True) + fqaoa.fermi_compile(po, budget) + fqaoa.optimize() + result = fqaoa.result.most_probable_states["solutions_bitstrings"][0] + assert "11010" == result + + def test_set_device_local(self): + """ " + Check that all local devices are correctly initialised + """ + fqaoa = FQAOA() + for d in fqaoa.local_simulators: + if d == 'analytical_simulator': + continue # Skip this + fqaoa.set_device(create_device(location="local", name=d)) + assert type(fqaoa.device) == DeviceLocal + assert fqaoa.device.device_name == d + assert fqaoa.device.device_location == "local" + + def test_compile_before_optimise(self): + """ + Assert that compilation has to be called before optimisation + """ + + fqaoa = FQAOA() + fqaoa.set_classical_optimizer(optimization_progress=True) + + self.assertRaises(ValueError, lambda: fqaoa.optimize()) + + def test_cost_hamil(self): + num_assets, budget = 5, 3 + mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) + qubo_problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo + + test_hamil = Hamiltonian.classical_hamiltonian( + terms=qubo_problem.terms, + coeffs=qubo_problem.weights, + constant=qubo_problem.constant, + ) + + fqaoa = FQAOA() + + fqaoa.fermi_compile(problem=qubo_problem, n_fermions=budget) + + self.assertEqual(fqaoa.cost_hamil.expression, test_hamil.expression) + self.assertEqual( + fqaoa.qaoa_descriptor.cost_hamiltonian.expression, test_hamil.expression + ) + + def test_set_circuit_properties_fourier_q(self): + """ + The value of q should be None if the param_type used is not fourier. + Else if param_type is fourier, fourier_extended or fourier_w_bias, it + should be the value of q, if it is provided. + """ + + fourier_param_types = ["fourier", "fourier_extended", "fourier_w_bias"] + + fqaoa = FQAOA() + + for each_param_type in fourier_param_types: + fqaoa.set_circuit_properties(param_type=each_param_type, q=1) + self.assertEqual(fqaoa.circuit_properties.q, 1) + + fqaoa.set_circuit_properties(param_type="standard", q=1) + + self.assertEqual(fqaoa.circuit_properties.q, None) + + def test_set_circuit_properties_annealing_time_linear_ramp_time(self): + """ + Check that linear_ramp_time and annealing_time are updated appropriately + as the value of p is changed. + """ + + fqaoa = FQAOA() + + fqaoa.set_circuit_properties(p=3) + + self.assertEqual(fqaoa.circuit_properties.annealing_time, 0.7 * 3) + self.assertEqual(fqaoa.circuit_properties.linear_ramp_time, 0.7 * 3) + + fqaoa.set_circuit_properties(p=2) + + self.assertEqual(fqaoa.circuit_properties.annealing_time, 0.7 * 2) + self.assertEqual(fqaoa.circuit_properties.linear_ramp_time, 0.7 * 2) + + def test_set_circuit_properties_qaoa_descriptor_mixer_x(self): + """ + Checks if the X mixer created by the X_mixer_hamiltonian method + and the automated methods in workflows do the same thing. + + For each qubit, there should be 1 RXGateMap per layer of p. + """ + + nodes = 6 + edge_probability = 0.6 + g = nw.generators.fast_gnp_random_graph(n=nodes, p=edge_probability) + problem = MinimumVertexCover(g, field=1.0, penalty=10) + + fqaoa = FQAOA() + self.assertRaises( + ValueError, lambda: fqaoa.set_circuit_properties(param_type="wrong name") + ) + + def test_set_circuit_properties_qaoa_descriptor_mixer_xy(self): + """ + Checks if the XY mixer created by the XY_mixer_hamiltonian method + and the automated methods in workflows do the same thing. + + Depending on the qubit connectivity selected. (chain, full or star) + For each pair of connected qubits, there should be 1 RXXGateMap and RYYGateMap per layer of p. + """ + + num_assets, budget = 5, 3 + mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) + problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo + + qubit_connectivity_name = ["cyclic", "chain"] + + for i in range(2): + fqaoa = FQAOA() + fqaoa.set_circuit_properties( + mixer_hamiltonian="xy", + mixer_qubit_connectivity=qubit_connectivity_name[i], + p=2, + ) + + fqaoa.fermi_compile(problem, budget, hopping = -1.0) + + self.assertEqual(type(fqaoa.qaoa_descriptor), QAOADescriptor) + self.assertEqual(fqaoa.qaoa_descriptor.p, 2) + + mixer_hamil = XY_mixer_hamiltonian( + n_qubits=num_assets, qubit_connectivity=qubit_connectivity_name[i] + ) + + self.assertEqual(fqaoa.mixer_hamil.expression, mixer_hamil.expression) + + self.assertEqual(len(fqaoa.qaoa_descriptor.mixer_qubits_singles), 0) + for i in range(0, len(fqaoa.qaoa_descriptor.mixer_qubits_pairs), 2): + self.assertEqual(fqaoa.qaoa_descriptor.mixer_qubits_pairs[i], "RXXGateMap") + self.assertEqual( + fqaoa.qaoa_descriptor.mixer_qubits_pairs[i + 1], "RYYGateMap" + ) + + def test_set_circuit_properties_variate_params(self): + """ + Ensure that the Varitional Parameter Object created based on the input string , param_type, is correct. + + TODO: Check if q=None is the appropriate default. + """ + + param_type_names = [ + "standard", + "standard_w_bias", + "extended", + "fourier", + "fourier_extended", + "fourier_w_bias", + ] + object_types = [ + QAOAVariationalStandardParams, + QAOAVariationalStandardWithBiasParams, + QAOAVariationalExtendedParams, + QAOAVariationalFourierParams, + QAOAVariationalFourierExtendedParams, + QAOAVariationalFourierWithBiasParams, + ] + + num_assets, budget = 5, 3 + mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) + problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None) + + for i in range(len(object_types)): + fqaoa = FQAOA() + fqaoa.set_circuit_properties(param_type=param_type_names[i], q=1) + + fqaoa.fermi_compile(problem=problem.qubo, n_fermions=budget) + + self.assertEqual(type(fqaoa.variate_params), object_types[i]) + + def test_set_circuit_properties_change(self): + """ + Ensure that once a property has beefn changed via set_circuit_properties. + The attribute has been appropriately updated. + Updating all attributes at the same time. + """ + + # default_pairings = {'param_type': 'standard', + # 'init_type': 'ramp', + # 'qubit_register': [], + # 'p': 1, + # 'q': None, + # 'annealing_time': 0.7, + # 'linear_ramp_time': 0.7, + # 'variational_params_dict': {}, + # 'mixer_hamiltonian': 'x', + # 'mixer_qubit_connectivity': None, + # 'mixer_coeffs': None, + # 'seed': None} + + fqaoa = FQAOA() + + # TODO: Some weird error related to the initialisation of QAOA here + # for each_key, each_value in default_pairings.items(): + # print(each_key, getattr(fqaoa.circuit_properties, each_key), each_value) + # self.assertEqual(getattr(fqaoa.circuit_properties, each_key), each_value) + + update_pairings = { + "param_type": "fourier", + "init_type": "rand", + "qubit_register": [0, 1], + "p": 2, + "q": 2, + "annealing_time": 1.0, + "linear_ramp_time": 1.0, + "variational_params_dict": {"key": "value"}, + "mixer_hamiltonian": "xy", + "mixer_qubit_connectivity": "chain", + "mixer_coeffs": [0.1, 0.2], + "seed": 45, + } + + fqaoa.set_circuit_properties(**update_pairings) + + for each_key, each_value in update_pairings.items(): + self.assertEqual(getattr(fqaoa.circuit_properties, each_key), each_value) + + def test_set_circuit_properties_rejected_values(self): + """ + Some properties of CircuitProperties Object return a ValueError + if the specified property has not been whitelisted in the code. + This checks that the ValueError is raised if the argument is not whitelisted. + """ + + fqaoa = FQAOA() + + self.assertRaises( + ValueError, lambda: fqaoa.set_circuit_properties(param_type="wrong name") + ) + self.assertRaises( + ValueError, lambda: fqaoa.set_circuit_properties(init_type="wrong name") + ) + self.assertRaises( + ValueError, lambda: fqaoa.set_circuit_properties(mixer_hamiltonian="wrong name") + ) + self.assertRaises(ValueError, lambda: fqaoa.set_circuit_properties(p=-1)) + + def test_set_backend_properties_change(self): + """ + Ensure that once a property has been changed via set_backend_properties. + The attribute has been appropriately updated. + Updating all attributes at the same time. + """ + + default_pairings = { + "n_shots": 100, + "cvar_alpha": 1.0, + } + + fqaoa = FQAOA() + + for each_key, each_value in default_pairings.items(): + self.assertEqual(getattr(fqaoa.backend_properties, each_key), each_value) + + update_pairings = { + "n_shots": 10, + "cvar_alpha": 0.5, + } + + fqaoa.set_backend_properties(**update_pairings) + + for each_key, each_value in update_pairings.items(): + self.assertEqual(getattr(fqaoa.backend_properties, each_key), each_value) + + def test_set_backend_init_hadamard_change(self): + """ + Ensure that an error occurs if the `init_hadmard` in the backend properties is set True. + """ + + fqaoa = FQAOA() + + self.assertFalse(fqaoa.backend_properties.init_hadamard) + + with self.assertRaises(ValueError): + fqaoa.set_backend_properties(init_hadamard=True) + + def test_set_backend_init_prepend_state_change(self): + """ + Ensure that an error occurs if the `prepend_state` is set by the set_backend method. + """ + + fqaoa = FQAOA() + + self.assertIsNone(fqaoa.backend_properties.prepend_state) + prepend_state_rand = np.random.rand(2**2) + with self.assertRaises(ValueError): + fqaoa.set_backend_properties(prepend_state=prepend_state_rand) + + def test_set_backend_init_append_state_change(self): + """ + Ensure that an error occurs if the `append_state` is set by the set_backend method. + """ + + fqaoa = FQAOA() + + self.assertIsNone(fqaoa.backend_properties.append_state) + append_state_rand = np.random.rand(2**2) + with self.assertRaises(ValueError): + fqaoa.set_backend_properties(append_state=append_state_rand) + + def test_set_backend_properties_check_backend_vectorized(self): + """ + Check if the backend returned by set_backend_properties is correct + Based on the input device. + Also Checks if defaults from workflows are used in the backend. + """ + + num_assets, budget = 5, 3 + mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) + problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None) + + fqaoa = FQAOA() + fqaoa.set_device(create_device(location="local", name="vectorized")) + fqaoa.fermi_compile(problem=problem.qubo, n_fermions=3) + + orbitals = get_analytical_fermi_orbitals(n_qubits=num_assets, n_fermions=budget, lattice="cyclic", hopping=1.0) + initial_state = get_statevector(orbitals) + + self.assertEqual(type(fqaoa.backend), QAOAvectorizedBackendSimulator) + + self.assertEqual(fqaoa.backend.init_hadamard, False) + self.assertTrue(np.array_equal(fqaoa.backend.prepend_state, initial_state)) + self.assertEqual(fqaoa.backend.append_state, None) + self.assertEqual(fqaoa.backend.cvar_alpha, 1) + + self.assertRaises(AttributeError, lambda: fqaoa.backend.n_shots) + + def test_set_backend_properties_check_backend_vectorized_w_custom(self): + """ + Check if the backend returned by set_backend_properties is correct + Based on the input device. + Uses custom values for attributes in backend_properties and checks if the + backend object responds appropriately. + """ + + num_assets, budget = 5, 3 + mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) + qubo_problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo + + fqaoa = FQAOA() + fqaoa.set_device(create_device(location="local", name="vectorized")) + + update_pairings = { + "n_shots": 10, + "cvar_alpha": 1, + } + + fqaoa.set_backend_properties(**update_pairings) + + fqaoa.fermi_compile(problem=qubo_problem, n_fermions=budget) + + orbitals = get_analytical_fermi_orbitals(n_qubits=num_assets, n_fermions=budget, lattice="cyclic", hopping=1.0) + initial_state = get_statevector(orbitals) + + self.assertEqual(type(fqaoa.backend), QAOAvectorizedBackendSimulator) + + self.assertTrue(np.array_equal(fqaoa.backend.prepend_state, initial_state)) + self.assertEqual(fqaoa.backend.cvar_alpha, 1) + + self.assertRaises(AttributeError, lambda: fqaoa.backend.n_shots) + + def test_set_classical_optimizer_defaults(self): + pass + + def test_set_classical_optimizer_jac_hess_casing(self): + pass + + def test_set_classical_optimizer_method_selectors(self): + pass + + def test_set_header(self): + pass + + def test_set_exp_tags(self): + pass + + def test_qaoa_evaluate_circuit(self): + """ + test the evaluate_circuit method + """ + + # problem + num_assets, budget = 5, 3 + mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) + problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo + + # run qaoa with different param_type, and save the objcets in a list + fqaoas = [] + for param_type in PARAMS_CLASSES_MAPPER.keys(): + fqaoa = FQAOA() + fqaoa.set_circuit_properties( + p=3, param_type=param_type, init_type="rand", seed=0 + ) + fqaoa.fermi_compile(problem=problem, n_fermions=budget) + fqaoas.append(fqaoa) + + # for each qaoa object, test the evaluate_circuit method + for fqaoa in fqaoas: + # evaluate the circuit with random dict of params + params = { + k: np.random.rand(*v.shape) + for k, v in fqaoa.variate_params.asdict().items() + } + result = fqaoa.evaluate_circuit(params) + assert ( + abs(result["cost"]) >= 0 + ), f"param_type={fqaoa.circuit_properties.param_type}. `evaluate_circuit` \ + should return a cost, here cost is {result['cost']}" + assert ( + abs(result["uncertainty"]) > 0 + ), f"param_type={fqaoa.circuit_properties.param_type}. `evaluate_circuit` should return an uncertanty, \ + here uncertainty is {result['uncertainty']}" + assert ( + len(result["measurement_results"]) > 0 + ), f"param_type={fqaoa.circuit_properties.param_type}. `evaluate_circuit` should return \ + a wavefunction when using a state-based simulator" + + # evaluate the circuit with a list of params, taking the params from the dict, + # so we should get the same result + params2 = [] + for value in params.values(): + params2 += value.flatten().tolist() + result2 = fqaoa.evaluate_circuit(params2) + for res, res2 in zip(result, result2): + self.assertAlmostEqual( + res, + res, + places=15, + msg=f"param_type={fqaoa.circuit_properties.param_type}. `evaluate_circuit` should return the same result \ + when passing a dict or a list of params" + ) + + # evaluate the circuit with np.ndarray of params, taking the params from the dict, + # so we should get the same result + result2 = fqaoa.evaluate_circuit(np.array(params2)) + for res, res2 in zip(result, result2): + self.assertAlmostEqual( + res, + res2, + places=15, + msg=f"param_type={fqaoa.circuit_properties.param_type}. `evaluate_circuit` should return the same result \ + when passing a dict or a list of params", + ) + + # evaluate the circuit with the params as a QAOAVariationalBaseParams object, + # so we should get the same result + params_obj = deepcopy(fqaoa.variate_params) + params_obj.update_from_raw(params2) + result3 = fqaoa.evaluate_circuit(params_obj) + for res, res3 in zip(result, result3): + self.assertAlmostEqual( + res, + res3, + places=15, + msg=f"param_type={fqaoa.circuit_properties.param_type}. `evaluate_circuit` should return the same result \ + when passing a dict or a list of params", + ) + + # run the circuit with the params manually, we should get the same result + result4 = {} + ( + result4["cost"], + result4["uncertainty"], + ) = fqaoa.backend.expectation_w_uncertainty(params_obj) + result4["measurement_results"] = fqaoa.backend.wavefunction(params_obj) + for res, res4 in zip(result, result4): + self.assertAlmostEqual( + res, + res4, + places=15, + msg=f"param_type={fqaoa.circuit_properties.param_type}. `evaluate_circuit` should return the same result \ + when passing the optimized params manually", + ) + + # evaluate the circuit with a wrong input, it should raise an error + with self.assertRaises( + TypeError, + msg=f"param_type={fqaoa.circuit_properties.param_type}. `evaluate_circuit` should raise an error when \ + passing a wrong input" + ): + fqaoa.evaluate_circuit(1) + + # evaluate the circuit with a list longer than it should, it should raise an error + with self.assertRaises( + AssertionError, + msg=f"param_type={fqaoa.circuit_properties.param_type}. `evaluate_circuit` should raise an error when \ + passing a list longer than it should" + ): + fqaoa.evaluate_circuit(params2 + [1]) + + # evaluate the circuit with a list shorter than it should, it should raise an error + with self.assertRaises( + AssertionError, + msg=f"param_type={fqaoa.circuit_properties.param_type}. `evaluate_circuit` should raise an error when \ + passing a list shorter than it should" + ): + fqaoa.evaluate_circuit(params2[:-1]) + + # evaluate the circuit with a dict with a wrong key, it should raise an error + with self.assertRaises( + KeyError, + msg=f"param_type={fqaoa.circuit_properties.param_type}. `evaluate_circuit` should raise an error \ + when passing a dict with a wrong key" + ): + fqaoa.evaluate_circuit({**params, "wrong_key": 1}) + + # evaluate the circuit with a dict with a value longer than it should, it should raise an error + with self.assertRaises( + ValueError, + msg=f"param_type={fqaoa.circuit_properties.param_type}. `evaluate_circuit` should raise an error when \ + passing a dict with a value longer than it should" + ): + fqaoa.evaluate_circuit( + {**params, list(params.keys())[0]: np.random.rand(40)} + ) + + # evaluate the circuit without passing any param, it should raise an error + with self.assertRaises( + TypeError, + msg=f"param_type={fqaoa.circuit_properties.param_type}. `evaluate_circuit` should raise an error when \ + not passing any param", + ): + fqaoa.evaluate_circuit() + + def test_qaoa_evaluate_circuit_shot(self): + # problem + num_assets, budget = 5, 3 + mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) + problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo + + if "qiskit.qasm_simulator" not in SUPPORTED_LOCAL_SIMULATORS: + self.skipTest( + reason="Qiskit QASM Simulator is not available. Please install the qiskit plugin: openqaoa-qiskit." + ) + else: + # check that it works with shots + fqaoa = FQAOA() + device = create_device(location="local", name="qiskit.qasm_simulator") + fqaoa.set_device(device) + fqaoa.set_circuit_properties(p=3) + + # try to evaluate the circuit before compiling + error = False + try: + fqaoa.evaluate_circuit() + except Exception: + error = True + assert ( + error + ), f"param_type={param_type}. `evaluate_circuit` should raise an error if the circuit is not compiled" + + # compile and evaluate the circuit, and check that the result is correct + fqaoa.fermi_compile(problem, budget) + result = fqaoa.evaluate_circuit([1, 2, 1, 2, 1, 2]) + assert isinstance( + result["measurement_results"], dict + ), "When using a shot-based simulator, `evaluate_circuit` should return a dict of counts" + assert ( + abs(result["cost"]) >= 0 + ), "When using a shot-based simulator, `evaluate_circuit` should return a cost" + assert ( + abs(result["uncertainty"]) > 0 + ), "When using a shot-based simulator, `evaluate_circuit` should return an uncertainty" + + cost = cost_function( + result["measurement_results"], + fqaoa.backend.qaoa_descriptor.cost_hamiltonian, + fqaoa.backend.cvar_alpha, + ) + cost_sq = cost_function( + result["measurement_results"], + fqaoa.backend.qaoa_descriptor.cost_hamiltonian.hamiltonian_squared, + fqaoa.backend.cvar_alpha, + ) + uncertainty = np.sqrt(cost_sq - cost**2) + assert ( + np.round(cost, 12) == result["cost"] + ), "When using a shot-based simulator, `evaluate_circuit` not returning the correct cost" + assert ( + np.round(uncertainty, 12) == result["uncertainty"] + ), "When using a shot-based simulator, `evaluate_circuit` not returning the correct uncertainty" + + def test_change_properties_after_compilation(self): + device = create_device(location="local", name="vectorized") + fqaoa = FQAOA() + fqaoa.fermi_compile(QUBO.random_instance(4), 2) + state_rand = np.random.rand(2**2) + + with self.assertRaises(ValueError): + fqaoa.set_device(device) + with self.assertRaises(ValueError): + fqaoa.set_circuit_properties( + p=1, param_type="standard", init_type="rand", + ) + with self.assertRaises(ValueError): + fqaoa.set_backend_properties(append_state=state_rand) + with self.assertRaises(ValueError): + fqaoa.set_backend_properties(prepend_state=state_rand) + with self.assertRaises(ValueError): + fqaoa.set_classical_optimizer( + maxiter=100, method="vgd", jac="finite_difference" + ) if __name__ == "__main__": unittest.main() From fe9eee425497fbffddb3935a79955e4e6563a987 Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Fri, 23 Aug 2024 13:13:07 +0900 Subject: [PATCH 07/26] new file: 16_FQAOA_examples.ipynb --- examples/16_FQAOA_examples.ipynb | 764 +++++++++++++++++++++++++++++++ 1 file changed, 764 insertions(+) create mode 100644 examples/16_FQAOA_examples.ipynb diff --git a/examples/16_FQAOA_examples.ipynb b/examples/16_FQAOA_examples.ipynb new file mode 100644 index 000000000..805cfc6cc --- /dev/null +++ b/examples/16_FQAOA_examples.ipynb @@ -0,0 +1,764 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c5de313a", + "metadata": {}, + "source": [ + "# 16 - Fermionic QAOA (FQAOA)\n", + "\n", + "This notebook provides a brief introduction to Fermionic QAOA (FQAOA). \n", + "It shows how this technique is implemented in the OpenQAOA workflow by solving the constrained quadratic optimization problem, an NP-hard problem.\n", + "\n", + "## A brief introduction\n", + "\n", + "We present an implementation of a novel algorithm designed for solving combinatorial optimization problems with constraints, utilizing the principles of quantum computing. The algorithm, known as the FQAOA [1, 2], introduces a significant enhancement over traditional methods by leveraging fermion particle number preservation. This intrinsic property allows the algorithm to enforce constraints naturally throughout the optimization process, addressing a critical challenge in many combinatorial problems.\n", + "\n", + "### Key Features\n", + "- Constraint Handling: In contrast to conventional approaches, which treat constraints as soft constraints in the cost function, FQAOA enforces constraints intrinsically by preserving fermion particle numbers, thereby enhancing the overall performance of the optimization algorithm.\n", + "\n", + "- Design of FQAOA Ansatz: In this algorithm,\n", + "the mixer is designed so that any classical state can be reached by its multiple actions.\n", + "The initial state is set to a ground state of the mixer Hamiltonian satisfying the constraints of the problem.\n", + "\n", + "- Adiabatic Evolution: FQAOA effectively reduces to quantum adiabatic computation in the large limit of circuit depth, $p$, offering improved performance even for shallow circuits by optimizing parameters starting from fixed angles determined by Trotterized quantum adiabatic evolution.\n", + "\n", + "- Performance Advantage: Extensive numerical simulations demonstrate that FQAOA offers substantial performance benefits over existing methods, particularly in portfolio optimization problems.\n", + "\n", + "- Broad Applicability: The Hamiltonian design guideline benefits QAOA and extends to other algorithms like Grover adaptive search and quantum phase estimation, making it a versatile tool for solving constrained combinatorial optimization problems.\n", + "\n", + "This notebook describes the implementation of FQAOA, illustrates its application through various examples, and provides insight into FQAOA's superior performance in constrained combinatorial optimization tasks.\n", + "\n", + "### Constrained Combinatorial Optimization Problems and Cost Hamiltonian\n", + "The constrained combinatorial optimization problem for a polynomial cost function　$C_{\\boldsymbol x}$ covered here can be written in the following form：\n", + "$${\\boldsymbol x}^* = \\arg \\min_{\\boldsymbol x} C_{\\boldsymbol x}\\qquad {\\rm s.t.} \\quad\\sum_{i=1}^{N} x_i = M,$$\n", + "with bit string ${\\boldsymbol x}\\in \\{0,1\\}^N$, where ${\\boldsymbol x}^*$ is the optimal solution.\n", + "This problem can be replaced by the minimum eigenvalue problem in the following steps.\n", + "\n", + "1. map the cost function $C_{\\boldsymbol x}$ to the cost Hamiltonian $\\hat{\\cal H}_C$ by $x_i\\rightarrow \\hat{n}_i$:\n", + "\\begin{eqnarray}\n", + "C_{\\boldsymbol x} &=& \\sum_i \\mu_i x_{i}+\\sum_{i,j} \\sigma_{i,j} x_{i}x_{j}\n", + "&\\quad\\mapsto\\quad&\\hat{\\cal H}_C=\\sum_i \\mu_i \\hat{n}_{i}+\\sum_{i,j} \\sigma_{i,j} \\hat{n}_{i_1}\\hat{n}_{i_2},\n", + "\\end{eqnarray}\n", + "where $\\hat{n}_i = \\hat{c}^\\dagger_i\\hat{c}_i$ is number operator and $\\hat{c}_i^\\dagger (\\hat{c}_i)$ is creation (annihilation) operator of fermion at $i$-th site.\n", + "\n", + "2. formulate eigen value problems for combinatorial optimization problem under the constraint:\n", + "\\begin{eqnarray}\n", + "\\hat{\\cal H}_C|x_1x_2\\cdots x_N\\rangle &=& C_{\\boldsymbol x}|x_1x_2\\cdots x_N\\rangle,\\\\\n", + "\\sum_{i=1}^{N} \\hat{n}_i|x_1x_2\\cdots x_N\\rangle &=& M|x_1x_2\\cdots x_N\\rangle,\n", + "\\end{eqnarray}\n", + "where $|x_1x_2\\cdots x_N\\rangle=(\\hat{c}^\\dagger_1)^{x_1}(\\hat{c}^\\dagger_2)^{x_2}\\cdots (\\hat{c}^\\dagger_N)^{x_N}|{\\rm vac}\\rangle$ is fermionic basis state and $|\\rm vac\\rangle$ is vacuum satisfying $\\hat{c}_i|\\rm vac\\rangle=0$.\n", + "\n", + "3. optimize FQAOA ansatz:\n", + "$$|\\psi_p({\\boldsymbol \\gamma}^*, {\\boldsymbol \\beta}^*)\\rangle \n", + "= \\left[\\prod_{j=1}^pU(\\hat{\\cal H}_M,\\beta_j^*){U}(\\hat{\\cal H}_C,\\gamma_j^*)\\right]\\hat{U}_{\\rm init}|{\\rm vac}\\rangle\n", + "\\qquad {\\rm by}\\quad\n", + "C_p({\\boldsymbol \\gamma}^*, {\\boldsymbol \\beta}^*)=\\min_{{\\boldsymbol \\gamma}, {\\boldsymbol \\beta}}C_p({\\boldsymbol \\gamma},{\\boldsymbol \\beta}),$$\n", + "$$\\qquad{\\rm where \\quad}C_p({\\boldsymbol \\gamma}, {\\boldsymbol \\beta}) = \\langle\\psi_p({\\boldsymbol \\gamma}, {\\boldsymbol \\beta})|\\hat{\\cal H}_C|\\psi_p({\\boldsymbol \\gamma}, {\\boldsymbol \\beta})\\rangle.$$\n", + "The variational parameters $({\\boldsymbol \\gamma}^*, {\\boldsymbol \\beta}^*)$ give the lowest cost value at QAOA level $p$.\n", + "\n", + "\n", + "### One-Dimensional Mixer Hamiltonian\n", + "\n", + "The FQAOA implemented on OpenQAOA employs mixer Hamiltonians on one-dimensional lattices. The main features of this computational model are summarized based on the study [2]:\n", + "\n", + "- Utilises a mixer Hamiltonian on a one-dimensional lattice dedicated to combinatorial optimization problems with equality constraints of the same coefficients.\n", + "\n", + "- Reduced Gate Operations: The new mixer Hamiltonian significantly reduces the number of gate operations in quantum circuits compared to previous studies [1], thus improving computational efficiency.\n", + "\n", + "- Noise suppression: as demonstrated in a 16-qubit trapped-ion quantum computer on Amazon Braket, the proposed mixer Hamiltonian effectively suppresses noise and improves algorithm performance.\n", + "\n", + "As these features enhance the performance and reliability of FQAOA for solving constrained combinatorial optimization problems, we focus on FQAOA with one-dimensional mixer hamiltonians.\n", + "\n", + "The specific mixer Hamiltonian $\\hat{\\cal H}_M$ on cyclic lattice to be implemented in OpenQAOA are as follow:\n", + "\n", + "\\begin{eqnarray}\n", + "\\hat{\\cal H}_M &=& t\\sum_{i=1}^{N-1} (\\hat{c}^\\dagger_i\\hat{c}_{i+1}+\\hat{c}^\\dagger_{i+1}\\hat{c}_i)-t(-1)^{M}(\\hat{c}^\\dagger_N\\hat{c}_{1}+\\hat{c}^\\dagger_{1}\\hat{c}_N).\n", + "\\end{eqnarray}\n", + "These Hamiltonians can be diagonalized as:\n", + "$$\\hat{\\cal H}_M=\\sum_{i=1}^{N}\\varepsilon_i\\hat{\\gamma}_i^\\dagger\\hat{\\gamma}_i \\qquad {\\rm with} \\quad\n", + "\\hat{\\gamma}_i^\\dagger = \\sum_{j=1}^N[\\phi_0]_{i,j}\\hat{c}^\\dagger_j,$$\n", + "where $[\\phi_0]$ is the unitary matrix used for the diagonalization and $\\varepsilon_i$ is eigenvalue.\n", + "The formulation and validation of the model on cyclic lattice are detailed in the study [2].\n", + "\n", + "### Initial State and Mixer for FQAOA\n", + "\n", + "We describe the specific calculation model utilized for our implementation of the FQAOA on cyclic lattice. \n", + "The initial state preparation unitary $\\hat{U}_{\\rm init}$ and the mixer $\\hat{U}_M$ used to implement the FQAOA are shown below.\n", + "\n", + "- initial state preparation unitary $\\hat{U}_{\\rm init}$ on cyclic lattice:\n", + "$$|\\phi_0\\rangle=\\hat{U}_{\\rm init}|{\\rm vac}\\rangle=\\left(\\prod_{i=1}^{M}\\hat{\\gamma}_i^\\dagger\\right)|{\\rm vac}\\rangle,\n", + "\\qquad{\\rm with}\\quad \\hat{U}_{\\rm init}=\\prod_{i=1}^{M}\\left(\\sum_{j=1}^N[\\phi_0]_{i,j}\\hat{c}^\\dagger_j\\right),$$\n", + "where $M$ is the number of fermions and $i$ indexes the eigenvalues $\\varepsilon_i$ in ascending order.\n", + "The implementation of the initial state preparation unitary on quantum circuit are shown in Refs. [1-3].\n", + "\n", + "- mixing unitary $U(\\hat{\\cal H}_M, \\beta)$ on cyclic lattice:\n", + "\\begin{eqnarray}\n", + "U(\\hat{\\cal H}_M, \\beta) &\\sim&\n", + "\\exp\\left[i\\beta t(-1)^M\\left(\\hat{c}^{\\dagger}_{ND}\\hat{c}_{1}+\\hat{c}^{\\dagger}_{1}\\hat{c}_{ND}\\right)\\right]\n", + "\\prod_{i\\ {\\rm even}}\\exp\\left[-i\\beta t\\left(\\hat{c}^{\\dagger}_i\\hat{c}_{i+1}+\\hat{c}^{\\dagger}_{i+1}\\hat{c}_{i}\\right)\\right]\n", + "\\prod_{i\\ {\\rm odd}}\\exp\\left[-i\\beta t\\left(\\hat{c}^{\\dagger}_i\\hat{c}_{i+1}+\\hat{c}^{\\dagger}_{i+1}\\hat{c}_{i}\\right)\\right],\n", + "\\end{eqnarray}\n", + "where the approximation by Trotter decomposition is applied, as certain hopping terms are non-commutative.\n", + "The implementation of the mixed unitary indicated on the right-hand side on quantum circuits is given in Refs. [1, 2, 4, 5]." + ] + }, + { + "cell_type": "markdown", + "id": "345d258f-4b46-4bd3-a709-7726b3e43b3c", + "metadata": {}, + "source": [ + "## Constrained Quadratic Optimization Problem" + ] + }, + { + "cell_type": "markdown", + "id": "ce6be6d4-7355-4ce8-bf68-17edb5f467ec", + "metadata": {}, + "source": [ + "The objective function of the constrined optimization problem is given by \n", + "\n", + "$$\\min_{x} : q {\\boldsymbol x}^{T} {\\boldsymbol \\sigma} {\\boldsymbol x}-{\\boldsymbol\\mu}^{T} {\\boldsymbol x},\\qquad {\\rm s.t.} \\quad\\sum_{i=1}^{N} x_i = M,$$\n", + "\n", + "where:\n", + "- $N$: number of decision variables,\n", + "- ${\\boldsymbol x} \\in\\{0,1\\}^{N}$: vector of binary decision variables,\n", + "- ${\\boldsymbol \\mu} \\in R^{n}$: vector coefficients for the linear term,\n", + "- ${\\boldsymbol \\sigma} \\in R^{n \\times n}$: symmetric positive semidefinite matrix for quadratic term,\n", + "- $q$: quadratic term coeffient,\n", + "- $M$: constraint on the sum of decision variables." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d3e2b171-0013-4e2e-9801-8a6a58d50370", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib notebook\n", + "%matplotlib inline\n", + "\n", + "# Import the libraries needed to employ the QAOA and FQAOA quantum algorithm using OpenQAOA\n", + "from openqaoa import FQAOA\n", + "from openqaoa import QAOA\n", + "\n", + "# method to covnert a docplex model to a qubo problem\n", + "from openqaoa.problems import PortfolioOptimization\n", + "from openqaoa.backends import create_device\n", + "from openqaoa.utilities import bitstring_energy\n", + "from openqaoa.algorithms.fqaoa import fqaoa_utils\n", + "\n", + "# Import external libraries to present an manipulate the data\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "8d47957a-251f-4206-8199-2c551713a754", + "metadata": {}, + "source": [ + "# Portfolio Optimizaton\n", + "\n", + "In the following, the [portfolio optimization problem](https://en.wikipedia.org/wiki/Portfolio_optimization) is taken as a constrained quadratic formal optimisation problem.\n", + "In this case, $N$ and $M$ in the equation are the number of the assets and the budget, respectively." + ] + }, + { + "cell_type": "markdown", + "id": "bb6a05c9-82f7-431b-b60f-de61cd71d3cf", + "metadata": {}, + "source": [ + "## Generate the input data\n", + "\n", + "To simplify the problem, it is used a random function to generate the predictions the expected return for 10 assets during 15 days as in [6]. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "06460e0b-e03f-46f3-8008-1ef9688f3e57", + "metadata": {}, + "outputs": [], + "source": [ + "# generate the input data for portfolio optimization\n", + "num_assets = 10 # number of assets\n", + "num_days = 15 # number of days\n", + "seed = 1 # seed of random number\n", + "mu, sigma, hist_exp = fqaoa_utils.generate_random_portfolio_data(num_assets, num_days, seed)" + ] + }, + { + "cell_type": "markdown", + "id": "af6a15f0-be1a-4fb4-81a8-6a352b7dcc27", + "metadata": {}, + "source": [ + "Graphical representation of 10 stock behavior and covariance matrix." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "dd4e138c-c112-49e7-862f-d8aa0f6ae69c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Covariance Matrix $\\\\Sigma$ associated to the risk')" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the stock's time series\n", + "fig, ax = plt.subplots(1, 2, figsize=(14,5))\n", + "colors = plt.cm.tab20(range(20))\n", + "for i in range(num_assets):\n", + " ax[0].plot(range(1, num_days+1), hist_exp[i], color=colors[i])\n", + "ax[0].set_xlabel(\"day\")\n", + "ax[0].set_ylabel(\"Expected Returns [$]\")\n", + "ax[0].legend([f\"Asset {i}\" for i in range(1, num_assets+1)])\n", + "im = ax[1].imshow(sigma, cmap=\"coolwarm\")\n", + "fig.colorbar(im)\n", + "\n", + "# Plot the covariance matrix\n", + "ax[1].set_yticks(range(num_assets))\n", + "ax[1].set_xticks(range(num_assets))\n", + "ax[1].set_xticklabels([f\"Asset {i}\" for i in range(1, num_assets+1)], rotation=45)\n", + "ax[1].set_yticklabels([f\"Asset {i}\" for i in range(1, num_assets+1)], rotation=45)\n", + "ax[1].set_title(r\"Covariance Matrix $\\Sigma$ associated to the risk\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d30abc93-34e2-41cd-9d9b-54773fe37a27", + "metadata": {}, + "outputs": [], + "source": [ + "# converts the portfolio optimization problem into a QUBO format.\n", + "budget = 5 # budget constraint value\n", + "problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo" + ] + }, + { + "cell_type": "markdown", + "id": "fe2621d4", + "metadata": {}, + "source": [ + "## Solving the problem using FQAOA" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6d2328a6-88f2-4a85-964e-d00f036d044a", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# Indicate the device, this case is a local simulator\n", + "device = create_device('local', 'qiskit.statevector_simulator')" + ] + }, + { + "cell_type": "markdown", + "id": "f54c48a2", + "metadata": {}, + "source": [ + "The quantum algorithms consider the following properties: the qiskit's statevector_simulator backend with a `p` value equals to 2, with `ramp` initialization." + ] + }, + { + "cell_type": "markdown", + "id": "f7eb209f-387b-4987-b642-e76f61168cf1", + "metadata": {}, + "source": [ + "### Optimization using FQAOA\n", + "\n", + "Here, a fermionic mixer Hamiltonian $\\hat{\\cal H}_M$ on cyclic lattice determines its ground state as the initial state $\\hat{U}_{\\rm init}|\\rm vac\\rangle$ and its mixer $U(\\hat{\\cal H}_M, \\beta)$." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "11087210-d89c-4b4d-a85a-576a1faad80f", + "metadata": {}, + "outputs": [], + "source": [ + "fqaoa = FQAOA(device)\n", + "fqaoa.set_circuit_properties(p=2)\n", + "fqaoa.fermi_compile(problem = problem, n_fermions = budget)\n", + "fqaoa.optimize()\n", + "fqaoa_results = fqaoa.result" + ] + }, + { + "cell_type": "markdown", + "id": "4c4dd7b9-0389-4689-a4fd-52917e6d7b06", + "metadata": {}, + "source": [ + "### Optimization using Conventional QAOA\n", + "\n", + "Here, the conventional X-mixer Hamiltonian $H_M$ determines its ground state as the initial state and its unitary transformation $\\exp(-i\\beta\\hat{\\cal H}_M)$ as the mixer." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0ee8df0b-e25d-4f9b-8304-1bdff0acb64b", + "metadata": {}, + "outputs": [], + "source": [ + "qaoa = QAOA(device)\n", + "qaoa.set_circuit_properties(p=2)\n", + "qaoa.compile(problem = problem)\n", + "qaoa.optimize()\n", + "qaoa_results = qaoa.result" + ] + }, + { + "cell_type": "markdown", + "id": "5bf46716-6f89-4e00-bbae-cbe8a991055e", + "metadata": {}, + "source": [ + "### Performance Evaluation of FQAOA" + ] + }, + { + "cell_type": "markdown", + "id": "7571203b-664e-40c9-ba7d-209372403a80", + "metadata": {}, + "source": [ + "To evalueate the performance of FQAOA, we show expectation value of costs. \n", + "We define normalized costs by \n", + "$\\Delta C_{\\boldsymbol x}/W$ with $\\Delta C_{\\boldsymbol x} = (C_{\\boldsymbol x}-C_{\\rm min})$ and $W=(C_{\\rm max}-C_{\\rm min})$, where $C_{\\rm max}$ ($C_{\\rm min}$) is maximum (minimum) value of cost under the cosntraint." + ] + }, + { + "cell_type": "markdown", + "id": "7f41514a-77d4-44c8-8cf1-990a2168d153", + "metadata": {}, + "source": [ + "#### maximum-minimum estimations of costs for normalization" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "fe328715-f5ef-4422-aae4-a5e9dd745942", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(min C_x, max C_x) = ( -2.6042725099164272 210.7614169508679 )\n" + ] + } + ], + "source": [ + "x_in_constraint = []\n", + "for i in range(2**num_assets):\n", + " bit = bin(i)[2:].zfill(num_assets)\n", + " cost = bitstring_energy(qaoa.cost_hamil, bit[::-1])\n", + " if bit.count('1') == budget:\n", + " x_in_constraint.append(cost)\n", + "max_x, min_x = max(x_in_constraint), min(x_in_constraint)\n", + "print('(min C_x, max C_x) = ', '(', min_x, max_x,')')" + ] + }, + { + "cell_type": "markdown", + "id": "d89b3c15-bea9-40c7-abe3-d0ba73897597", + "metadata": {}, + "source": [ + "#### cost history" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9b2c0b91-4de0-4362-9470-1d7a354e5418", + "metadata": {}, + "outputs": [], + "source": [ + "label_list = ['QAOA', 'FQAOA']\n", + "opt_results_list, cost_list = [], []\n", + "exp_cost_dict = {}\n", + "for opt_result in [qaoa_results, fqaoa_results]:\n", + " opt_results_list.append(opt_result)\n", + " cost_list.append(opt_result.optimized['cost'])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5125af92-c141-4aae-813c-e2f27956d1c2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 8))\n", + "for i, opt_results in enumerate(opt_results_list):\n", + " opt_results.plot_cost(ax=ax, color=f'C{i}', label=label_list[i])\n", + "ax.grid(True)\n", + "ylim_scaled = 8\n", + "ax.set_ylabel(r'normalized cost, $\\langle \\Delta C_{\\boldsymbol{x}}/W \\rangle$')\n", + "ax.set_ylim(min_x, min_x + ylim_scaled * (max_x - min_x))\n", + "ax.set_yticks([min_x + i * (max_x - min_x) for i in range(ylim_scaled + 1)],\n", + " labels=range(ylim_scaled + 1))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9c6dda49-9fb0-4235-9a7d-8e6ba14ecebf", + "metadata": {}, + "source": [ + "### Performance Evaluation of FQAOA" + ] + }, + { + "cell_type": "markdown", + "id": "11c7b1c7-2820-463a-9dd0-cc5b2ec533f3", + "metadata": {}, + "source": [ + "#### expection values of the cost" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e620d83e-0a6c-433a-af44-1b7a04f0d491", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "expectation values of the cost\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
method$\\langle C_{\\boldsymbol x} \\rangle$$\\langle \\Delta C_{\\boldsymbol x}\\rangle /W$
0QAOA1294.8386166.080841
1FQAOA27.0286620.138883
\n", + "
" + ], + "text/plain": [ + " method $\\langle C_{\\boldsymbol x} \\rangle$ \\\n", + "0 QAOA 1294.838616 \n", + "1 FQAOA 27.028662 \n", + "\n", + " $\\langle \\Delta C_{\\boldsymbol x}\\rangle /W$ \n", + "0 6.080841 \n", + "1 0.138883 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "exp_cost_dict['method'] = label_list\n", + "exp_cost_dict[r'$\\langle C_{\\boldsymbol x} \\rangle$'] = cost_list\n", + "exp_cost_dict[r'$\\langle \\Delta C_{\\boldsymbol x}\\rangle /W$'] = (np.array(cost_list)-min_x)/(max_x-min_x)\n", + "df = pd.DataFrame(exp_cost_dict)\n", + "print('expectation values of the cost')\n", + "display(df)" + ] + }, + { + "cell_type": "markdown", + "id": "5bb1d29c-9af8-4e6b-bb27-0fca690a7b65", + "metadata": {}, + "source": [ + "#### best 5 states" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "6373b123-b0d2-44db-a4d6-5d2ca44185d8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Comparison of methods for calculating the probability of finding the optimal solutions\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
solutions bitstrings, $\\boldsymbol{x}$cost, $C_{\\boldsymbol x}$normalized cost, $\\Delta C_{\\boldsymbol x}/W$Probability (QAOA)Probability (FQAOA)
01101100001-2.6042730.0000000.0000340.009313
11101000101-2.4729650.0006150.0000920.018148
21101001001-2.2997220.0014270.0000010.012510
31100100101-2.1608150.0020780.0000060.004845
41100100011-1.8206970.0036720.0000690.012701
\n", + "
" + ], + "text/plain": [ + " solutions bitstrings, $\\boldsymbol{x}$ cost, $C_{\\boldsymbol x}$ \\\n", + "0 1101100001 -2.604273 \n", + "1 1101000101 -2.472965 \n", + "2 1101001001 -2.299722 \n", + "3 1100100101 -2.160815 \n", + "4 1100100011 -1.820697 \n", + "\n", + " normalized cost, $\\Delta C_{\\boldsymbol x}/W$ Probability (QAOA) \\\n", + "0 0.000000 0.000034 \n", + "1 0.000615 0.000092 \n", + "2 0.001427 0.000001 \n", + "3 0.002078 0.000006 \n", + "4 0.003672 0.000069 \n", + "\n", + " Probability (FQAOA) \n", + "0 0.009313 \n", + "1 0.018148 \n", + "2 0.012510 \n", + "3 0.004845 \n", + "4 0.012701 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Print the best 5 solutions\n", + "lowest_dict = opt_results_list[0].lowest_cost_bitstrings(5)\n", + "list1 = lowest_dict['bitstrings_energies']\n", + "normalized_cost = [(x - min_x) / (max_x - min_x) for x in list1]\n", + "qaoa_dict = {\n", + " r'solutions bitstrings, $\\boldsymbol{x}$': lowest_dict['solutions_bitstrings'],\n", + " r'cost, $C_{\\boldsymbol x}$': list1,\n", + " r'normalized cost, $\\Delta C_{\\boldsymbol x}/W$': normalized_cost,\n", + " f'Probability ({label_list[0]})': lowest_dict.pop('probabilities'),\n", + " f'Probability ({label_list[1]})': opt_results_list[1].lowest_cost_bitstrings(5)['probabilities']\n", + "}\n", + "df = pd.DataFrame(qaoa_dict)\n", + "print('Comparison of methods for calculating the probability of finding the optimal solutions')\n", + "display(df)" + ] + }, + { + "cell_type": "markdown", + "id": "7ce08877-3234-485a-8abf-1b72ef0f98fc", + "metadata": {}, + "source": [ + "#### probability distribution of costs." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "de27622f-bfcb-4573-96d7-fbba08d1d159", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot energy distribution\n", + "xvalues, yvalues = [], []\n", + "for opt_results in opt_results_list:\n", + " measurement_outcomes = opt_results.optimized['measurement_outcomes']\n", + " costprob = []\n", + " for i, amplitude in enumerate(measurement_outcomes):\n", + " bit = bin(i)[2:].zfill(num_assets)\n", + " probability = abs(amplitude)**2\n", + " costprob.append([bitstring_energy(qaoa.cost_hamil, bit[::-1]), probability, bit])\n", + " # Extracting the second values from the data points for the histogram\n", + " xvalues.append([(point[0]-min_x)/(max_x-min_x) for point in costprob])\n", + " yvalues.append([point[1] for point in costprob])\n", + "xmax, bins = 1.0, 20\n", + "figsize=(10, 8)\n", + "fig, ax = plt.subplots(figsize=figsize)\n", + "ax.set_xlim(0, xmax)\n", + "ax.set_ylim(0, 0.5)\n", + "ax.hist(xvalues, bins = np.linspace(0, xmax, bins+1), weights=yvalues, edgecolor='black', label = label_list)\n", + "ax.set_xlabel(r'normalized cost, $\\Delta C_{\\boldsymbol{x}}/W$')\n", + "ax.set_ylabel('Probability')\n", + "ax.grid(True)\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8106c098-1fe7-43ad-b276-8aeeb57f0e7d", + "metadata": {}, + "source": [ + "# References\n", + "\n", + "[1] T. Yoshioka, K. Sasada, Y. Nakano, and K. Fujii, [Phys. Rev. Research 5, 023071 (2023).](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071), [arXiv: 2301.10756 [quant-ph]](https://arxiv.org/pdf/2301.10756). \\\n", + "[2] T. Yoshioka, K. Sasada, Y. Nakano, and K. Fujii, [2023 IEEE International Conference on Quantum Computing and Engineering (QCE) 1, 300-306 (2023).](https://ieeexplore.ieee.org/document/10313662), [arXiv: 2312.04710 [quant-phi]](https://arxiv.org/pdf/2312.04710). \\\n", + "[3] Z. Jiang, J. S. Kevin, K. Kechedzhi, V. N. Smelyanskiy, and S. Boixo, [Phys. Rev. Appl. 9, 044036 (2018).](https://journals.aps.org/prapplied/abstract/10.1103/PhysRevApplied.9.044036) \\\n", + "[4] S. Hadfield, Z. Wang, B. O’Gorman, E. G. Rieffel, D. Venturelli, and R. Biswas, [algorithms 12, 34 (2019).](https://www.mdpi.com/1999-4893/12/2/34) \\\n", + "[5] Z. Wang, N. C. Rubin, J. M. Dominy, and E. G. Rioeffel, [Phys. Rev. A 101, 012320 (2020).](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.101.012320) \\\n", + "[6] [openqaoa/examples/community_tutorials/03_portfolio_optimization.ipynb](https://github.com/entropicalabs/openqaoa/blob/main/examples/community_tutorials/03_portfolio_optimization.ipynb)" + ] + } + ], + "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": 5 +} From ce6450815fb537b2ec5d0e372863f4e05d7b57ec Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Fri, 23 Aug 2024 15:33:22 +0900 Subject: [PATCH 08/26] Add missing imports --- src/openqaoa-core/tests/test_workflows.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/openqaoa-core/tests/test_workflows.py b/src/openqaoa-core/tests/test_workflows.py index 59602eee6..2c5576c4d 100644 --- a/src/openqaoa-core/tests/test_workflows.py +++ b/src/openqaoa-core/tests/test_workflows.py @@ -7,7 +7,7 @@ import datetime from copy import deepcopy -from openqaoa import QAOA, RQAOA +from openqaoa import QAOA, RQAOA, FQAOA from openqaoa.problems import NumberPartition from openqaoa.algorithms import QAOAResult, RQAOAResult from openqaoa.algorithms.baseworkflow import Workflow @@ -23,6 +23,11 @@ CircuitProperties, ) from openqaoa.algorithms.rqaoa.rqaoa_workflow_properties import RqaoaParameters +from openqaoa.algorithms.fqaoa.fqaoa_utils import ( + get_analytical_fermi_orbitals, + get_statevector, + generate_random_portfolio_data, +) from openqaoa.backends import create_device, DeviceLocal from openqaoa.backends.cost_function import cost_function @@ -39,7 +44,7 @@ ) from openqaoa.backends import QAOAvectorizedBackendSimulator from openqaoa.backends.basebackend import QAOABaseBackendStatevector -from openqaoa.problems import MinimumVertexCover, QUBO, MaximumCut +from openqaoa.problems import MinimumVertexCover, PortfolioOptimization, QUBO, MaximumCut from openqaoa.optimizers.qaoa_optimizer import available_optimizers from openqaoa.optimizers.training_vqa import ( ScipyOptimizer, From 31da14209804397197df54b06aa873ffd3c93237 Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Mon, 26 Aug 2024 17:39:24 +0900 Subject: [PATCH 09/26] Update documentation for FQAOA --- docs/source/index.rst | 13 +++++++++++++ docs/source/openqaoa_core/fqaoa.rst | 10 ++++++++++ docs/source/openqaoa_core/openqaoa_core_api.rst | 3 ++- docs/source/openqaoa_core/workflows.rst | 8 ++++++-- .../openqaoa/algorithms/fqaoa/fqaoa_utils.py | 8 ++++---- 5 files changed, 35 insertions(+), 7 deletions(-) create mode 100644 docs/source/openqaoa_core/fqaoa.rst diff --git a/docs/source/index.rst b/docs/source/index.rst index ad7ec5f5d..7531a6a10 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -171,6 +171,18 @@ Your first RQAOA workflow rqaoa_type can take two values which select elimination strategies. The user can choose between `adaptive` or `custom`. +Your first FQAOA workflow +------------------------- + +.. code-block:: python + + from openqaoa import FQAOA + fqaoa = FQAOA() + fqaoa.fermi_compile(qubo_problem, n_fermions) + fqaoa.optimize() + +FQAOA intrinsically imposes a hard constraint where the hamming wieght is equal to n_fermions. + Factory mode ------------ The user is also free to directly access the source code without using the workflow API. @@ -305,6 +317,7 @@ Contents notebooks/14_qaoa_benchmark.ipynb notebooks/X_dumping_data.ipynb notebooks/15_Zero_Noise_Extrapolation.ipynb + notebooks/16_FQAOA_examples.ipynb Indices and tables ================== diff --git a/docs/source/openqaoa_core/fqaoa.rst b/docs/source/openqaoa_core/fqaoa.rst new file mode 100644 index 000000000..a6566c2e2 --- /dev/null +++ b/docs/source/openqaoa_core/fqaoa.rst @@ -0,0 +1,10 @@ +Fermionic QAOA functions +======================== + +A set of utility functions for FQAOA + +.. automodule:: openqaoa.algorithms.fqaoa.fqaoa_utils + :members: + :undoc-members: + :inherited-members: + diff --git a/docs/source/openqaoa_core/openqaoa_core_api.rst b/docs/source/openqaoa_core/openqaoa_core_api.rst index 2b1bf5e94..b7e89b35a 100644 --- a/docs/source/openqaoa_core/openqaoa_core_api.rst +++ b/docs/source/openqaoa_core/openqaoa_core_api.rst @@ -6,9 +6,10 @@ OpenQAOA Core API Reference workflows rqaoa + fqaoa problems qaoaparameters backends logger_and_results optimizers - utilities \ No newline at end of file + utilities diff --git a/docs/source/openqaoa_core/workflows.rst b/docs/source/openqaoa_core/workflows.rst index 5690dafc7..a8a422d56 100644 --- a/docs/source/openqaoa_core/workflows.rst +++ b/docs/source/openqaoa_core/workflows.rst @@ -1,7 +1,7 @@ Workflows ================================= -Workflows are a simple reference API to build complex quantum optimisations problems. Currently, it supports creations of `QAOA` and `Recursive QAOA` workflows. +Workflows are a simple reference API to build complex quantum optimisations problems. Currently, it supports creations of `QAOA`, `Recursive QAOA`, `Fermionic QAOA` workflows. Workflows are designed to aid the user to focus on the optimisation problem, while delegating the construction and the execution of the specific algorithm to `OpenQAOA` @@ -54,7 +54,11 @@ To choose the strategy, set the parameter ``rqaoa_type`` using the `set_rqaoa_pa :members: :undoc-members: :inherited-members: - + +.. autoclass:: openqaoa.algorithms.fqaoa.fqaoa_workflow.FQAOA + :members: + :undoc-members: + :inherited-members: RQAOA Workflow Properties ------------------------- diff --git a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py index fe50f08f4..0f29d73f9 100644 --- a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py +++ b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py @@ -1,4 +1,4 @@ -from typing import List, Optional, Tuple +from typing import List, Optional from itertools import combinations from scipy import linalg import numpy as np @@ -169,7 +169,7 @@ def get_analytical_fermi_orbitals( raise ValueError("analytical solutions support only 'cyclic'") if hopping <= 0.0: raise ValueError("analytical solutions support hopping > 0") - + orbitals = np.zeros((n_fermions, n_qubits), dtype = np.float64) if n_fermions % 2 == 0: for jw in range(n_qubits): @@ -261,7 +261,7 @@ def generate_random_portfolio_data( num_assets: int, num_days: int, seed: Optional[int] = None, -) -> Tuple[List[float], List[List[float]], np.ndarray]: +) -> tuple[list[float], list[list[float]], np.ndarray]: """ Generates random portfolio data including mean returns, covariance matrix, and historical price movements for a given number of assets and days. @@ -290,7 +290,7 @@ def generate_random_portfolio_data( influenced by a time trend and random fluctuations, suitable for use in portfolio optimization and risk analysis. """ - + # If a seed is provided, set the random seed if seed is not None: np.random.seed(seed) From ed49ccb46bd2d06ca510066bec873411e431eeef Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Wed, 28 Aug 2024 06:28:02 +0900 Subject: [PATCH 10/26] new file: 17_demonstration_of_quantum_annealing_with_FQAOA.ipynb --- ...tion_of_quantum_annealing_with_FQAOA.ipynb | 293 ++++++++++++++++++ 1 file changed, 293 insertions(+) create mode 100644 examples/17_demonstration_of_quantum_annealing_with_FQAOA.ipynb diff --git a/examples/17_demonstration_of_quantum_annealing_with_FQAOA.ipynb b/examples/17_demonstration_of_quantum_annealing_with_FQAOA.ipynb new file mode 100644 index 000000000..3dabb39d5 --- /dev/null +++ b/examples/17_demonstration_of_quantum_annealing_with_FQAOA.ipynb @@ -0,0 +1,293 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c5de313a", + "metadata": {}, + "source": [ + "# 17 - Demonstration of Quantum Annealing with FQAOA\n", + "\n", + "The framework of Fermionic QAOA (FQAOA) covers the Quantum Annealing (QA) framework [1]. In this note, we demonstrate that QA with FQAOA works for constrained combinatorial optimisation problems in practice and compare its performance with QA with conventional QAOA [2].\n", + "\n", + "## FQAOA Ansatz for QA\n", + "FQAOA supports a discretised form of quantum annealing.\n", + "Quantum annealing starts with a mixer Hamiltonian ground state and gradually evolves to a cost Hamiltonian ground state.\n", + "If the transformation can be performed slowly to infinity, it is guaranteed to reach the exact ground state of the cost Hamiltonian.\n", + "In practice, the transformation is performed over a finite time and we want to prepare the ground state with some high probability.\n", + "\n", + "The approximated ground state obtained by QA are as follows:\n", + "$$|\\psi(T)\\rangle = {\\cal T}\\exp\\left\\{ -i\\int_0^T \\left[\\left(1-\\frac{t}{T}\\right)\\hat{\\cal H}_M+\\frac{t}{T}\\hat{\\cal H}_C\\right] dt\\right\\}\\hat{U}_{\\rm init}|{\\rm vac}\\rangle,$$\n", + "where the cost $\\hat{\\cal H}_C$ and mixer $\\hat{\\cal H}_M$ Hamiltonians, and initial state preparation unitary $\\hat{U}_{\\rm init}$ are given in the notebook (16_FQAOA_examples.ipynb)[./16_FQAOA_examples.ipynb]. $T$ is annealing time and $\\cal T$ is time ordering product for $t$.\n", + "\n", + "The $|\\psi(T)\\rangle$ is approximated in the following form for calculation in quantum circuits [1, 2]:\n", + "$$|\\psi(T)\\rangle\\sim|\\psi_p({\\boldsymbol \\gamma}^{(0)}, {\\boldsymbol \\beta}^{(0)})\\rangle \n", + "= \\left[\\prod_{j=1}^pU(\\hat{\\cal H}_M,\\beta_j^{(0)}){U}(\\hat{\\cal H}_C,\\gamma_j^{(0)})\\right]\\hat{U}_{\\rm init}|{\\rm vac}\\rangle,$$\n", + "with\n", + "\\begin{eqnarray}\n", + " \\gamma_j^{(0)} &=& \\frac{2j-1}{2p}\\Delta t, \\\\\n", + " \\beta_j^{(0)} &=& \\left(1-\\frac{2j-1}{2p}\\right)\\Delta t,\n", + "\\end{eqnarray}\n", + "where $\\Delta t$ is the unit of descretized annealing time, as $T=p\\Delta t$.\n", + "\n", + "In the FQAOA ansatz, the following constraints can be imposed on any integer $M$ smaller than the number of qubits $N$ as:\n", + "$$\\sum_{i=1}^{N} \\hat{n}_i|\\psi_p({\\boldsymbol \\gamma^{(0)}}, {\\boldsymbol \\beta}^{(0)})\\rangle = M|\\psi_p({\\boldsymbol \\gamma^{(0)}}, {\\boldsymbol \\beta}^{(0)})\\rangle,$$\n", + "where $\\hat{n}_i = \\hat{c}^\\dagger_i\\hat{c}_i$ is number operator and $\\hat{c}_i^\\dagger (\\hat{c}_i)$ is creation (annihilation) operator of fermion at $i$-th site.\n", + "\n", + "The FQAOA ansatz is also improved from $|\\psi_p({\\boldsymbol \\gamma}^{(0)}, {\\boldsymbol \\beta}^{(0)})\\rangle$ by setting ${\\boldsymbol \\gamma}^{(0)}, {\\boldsymbol \\beta}^{(0)}$ as initial parameters and running FQAOA. Thus, the performance of the FQAOA framework is guaranteed by QA.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d3e2b171-0013-4e2e-9801-8a6a58d50370", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib notebook\n", + "%matplotlib inline\n", + "\n", + "# Import the libraries needed to employ the QAOA and FQAOA quantum algorithm using OpenQAOA\n", + "from openqaoa import FQAOA\n", + "from openqaoa import QAOA\n", + "\n", + "# method to covnert a docplex model to a qubo problem\n", + "from openqaoa.problems import PortfolioOptimization\n", + "from openqaoa.backends import create_device\n", + "from openqaoa.algorithms.fqaoa import fqaoa_utils\n", + "\n", + "# Import external libraries to present an manipulate the data\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Indicate the device, this case is a local simulator\n", + "device = create_device('local', 'vectorized')" + ] + }, + { + "cell_type": "markdown", + "id": "8d47957a-251f-4206-8199-2c551713a754", + "metadata": {}, + "source": [ + "In the following, the [portfolio optimization problem](https://en.wikipedia.org/wiki/Portfolio_optimization) is taken as a constrained quadratic formal optimisation problem.\n", + "In this case, $N$ and $M$ in the equation are the number of the assets and the budget, respectively." + ] + }, + { + "cell_type": "markdown", + "id": "bb6a05c9-82f7-431b-b60f-de61cd71d3cf", + "metadata": {}, + "source": [ + "## Create a Problem Instance\n", + "\n", + "To simplify the problem, it is used a random function to generate the predictions the expected return for 10 assets during 15 days as in [6]. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "06460e0b-e03f-46f3-8008-1ef9688f3e57", + "metadata": {}, + "outputs": [], + "source": [ + "# generate the input data for portfolio optimization\n", + "num_assets = 4 # number of assets\n", + "budget = 2 # budget constraint value\n", + "num_days = 15 # number of days\n", + "seed = 1 # seed of random number\n", + "mu, sigma, hist_exp = fqaoa_utils.generate_random_portfolio_data(num_assets, num_days, seed)\n", + "problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo" + ] + }, + { + "cell_type": "markdown", + "id": "f7eb209f-387b-4987-b642-e76f61168cf1", + "metadata": {}, + "source": [ + "## Execute Quantum Annealing\n", + "\n", + "Here, a fermionic mixer Hamiltonian $\\hat{\\cal H}_M$ on cyclic lattice determines its ground state as the initial state $\\hat{U}_{\\rm init}|\\rm vac\\rangle$ and its mixer $U(\\hat{\\cal H}_M, \\beta)$." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "11087210-d89c-4b4d-a85a-576a1faad80f", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# QA using FQAOA\n", + "fqaoa_cost_list = []\n", + "fqaoa_ip_values = range(1, 21)\n", + "fqaoa_dt = 0.1\n", + "\n", + "for ip in fqaoa_ip_values:\n", + " fqaoa = FQAOA(device)\n", + " fqaoa.set_circuit_properties(p=ip, param_type='annealing', init_type='ramp', annealing_time=fqaoa_dt*ip)\n", + " fqaoa.set_classical_optimizer(maxiter=0)\n", + " fqaoa.fermi_compile(problem = problem, n_fermions = budget)\n", + " fqaoa.optimize()\n", + " fqaoa_cost_list.append(fqaoa.result.optimized['cost'])" + ] + }, + { + "cell_type": "markdown", + "id": "4c4dd7b9-0389-4689-a4fd-52917e6d7b06", + "metadata": {}, + "source": [ + "Here, the conventional X-mixer Hamiltonian $H_M$ determines its ground state as the initial state and its unitary transformation $\\exp(-i\\beta\\hat{\\cal H}_M)$ as the mixer." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0ee8df0b-e25d-4f9b-8304-1bdff0acb64b", + "metadata": {}, + "outputs": [], + "source": [ + "# QA using QAOA\n", + "qaoa_cost_list = []\n", + "qaoa_ip_values = range(1, 101)\n", + "qaoa_dt = 0.01\n", + "\n", + "for ip in qaoa_ip_values:\n", + " qaoa = QAOA(device)\n", + " qaoa.set_circuit_properties(p=ip, param_type='annealing', init_type='ramp', annealing_time=qaoa_dt*ip)\n", + " qaoa.set_classical_optimizer(maxiter=0)\n", + " qaoa.compile(problem = problem)\n", + " qaoa.optimize()\n", + " qaoa_cost_list.append(qaoa.result.optimized['cost'])" + ] + }, + { + "cell_type": "markdown", + "id": "ef9f898f-32fa-471d-8fb3-3d97a7b1b0d7", + "metadata": {}, + "source": [ + "## Plotting the Results and Comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d2e67f5f-b0d7-4db1-9973-9dc8013f0aa9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting the FQAOA results\n", + "plt.plot(fqaoa_ip_values, fqaoa_cost_list, marker='o')\n", + "plt.xlabel('p')\n", + "plt.ylabel('Cost')\n", + "plt.xlim(0, 20)\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "56b60100-6588-4353-9d7a-f19645693030", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting the QAOA results\n", + "plt.plot(qaoa_ip_values, qaoa_cost_list, marker='x', label='QAOA', color='C1')\n", + "plt.xlabel('p')\n", + "plt.ylabel('Cost')\n", + "plt.xlim(0, 20)\n", + "plt.ylim(92.5,107.5)\n", + "plt.grid(True)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "51385cb6-0205-48ce-994f-5f4bbd6ce2af", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting costs against annealing time\n", + "fqaoa_annealing_times = [ip * 0.1 for ip in fqaoa_ip_values]\n", + "qaoa_annealing_times = [ip * 0.01 for ip in qaoa_ip_values]\n", + "\n", + "# Plotting the results\n", + "plt.plot(fqaoa_annealing_times, fqaoa_cost_list, marker='o', label='FQAOA')\n", + "plt.plot(qaoa_annealing_times, qaoa_cost_list, marker='x', label='QAOA')\n", + "plt.xlabel('Annealing Time $T$')\n", + "plt.ylabel('Cost')\n", + "plt.title(r'Quantum Annealing Cost vs. Annealing Time')\n", + "plt.xlim(0, 1)\n", + "plt.grid(True)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8106c098-1fe7-43ad-b276-8aeeb57f0e7d", + "metadata": {}, + "source": [ + "# References\n", + "[1] T. Yoshioka, K. Sasada, Y. Nakano, and K. Fujii, [Phys. Rev. Research 5, 023071 (2023).](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071), [arXiv: 2301.10756 [quant-ph]](https://arxiv.org/pdf/2301.10756).\\\n", + "[2] E. Farhi, J. Goldston, S. Gutmann, M. Sipser, [arXiv:quant-ph/0001106](https://arxiv.org/pdf/quant-ph/0001106)." + ] + } + ], + "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": 5 +} From d3f08b10a629eff1b2bb4ebb11cef35ffafed273 Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Wed, 28 Aug 2024 11:34:48 +0900 Subject: [PATCH 11/26] Rename file: 17_demonstration_of_quantum_annealing_with_FQAOA.ipynb --- .../17_FQAOA_advanced_parameterization.ipynb | 345 ++++++++++++++++++ ...tion_of_quantum_annealing_with_FQAOA.ipynb | 293 --------------- 2 files changed, 345 insertions(+), 293 deletions(-) create mode 100644 examples/17_FQAOA_advanced_parameterization.ipynb delete mode 100644 examples/17_demonstration_of_quantum_annealing_with_FQAOA.ipynb diff --git a/examples/17_FQAOA_advanced_parameterization.ipynb b/examples/17_FQAOA_advanced_parameterization.ipynb new file mode 100644 index 000000000..10dcfcfb2 --- /dev/null +++ b/examples/17_FQAOA_advanced_parameterization.ipynb @@ -0,0 +1,345 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c5de313a", + "metadata": {}, + "source": [ + "# 17 - FQAOA circuit with advanced circuit parameterizations\n", + "\n", + "This notebook describes how to apply the annealing and Fourier parameter classes included in OpenQAOA to FAOA frame work." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d3e2b171-0013-4e2e-9801-8a6a58d50370", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib notebook\n", + "%matplotlib inline\n", + "\n", + "# Import the libraries needed to employ the QAOA and FQAOA quantum algorithm using OpenQAOA\n", + "from openqaoa import FQAOA\n", + "from openqaoa import QAOA\n", + "\n", + "# method to covnert a docplex model to a qubo problem\n", + "from openqaoa.problems import PortfolioOptimization\n", + "from openqaoa.backends import create_device\n", + "from openqaoa.algorithms.fqaoa import fqaoa_utils\n", + "\n", + "# Import external libraries to present an manipulate the data\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Indicate the device, this case is a local simulator\n", + "device = create_device('local', 'vectorized')" + ] + }, + { + "cell_type": "markdown", + "id": "bb6a05c9-82f7-431b-b60f-de61cd71d3cf", + "metadata": {}, + "source": [ + "### Create a Problem Instance\n", + "\n", + "To simplify the problem, it is used a random function to generate the predictions the expected return for 10 assets during 15 days as in [6]. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "06460e0b-e03f-46f3-8008-1ef9688f3e57", + "metadata": {}, + "outputs": [], + "source": [ + "# generate the input data for portfolio optimization\n", + "num_assets = 4 # number of assets\n", + "budget = 2 # budget constraint value\n", + "num_days = 15 # number of days\n", + "seed = 1 # seed of random number\n", + "mu, sigma, hist_exp = fqaoa_utils.generate_random_portfolio_data(num_assets, num_days, seed)\n", + "problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo" + ] + }, + { + "cell_type": "markdown", + "id": "c94dc5c2-136b-4683-86d9-64448daeca05", + "metadata": {}, + "source": [ + "## Quantum Annealing with FQAOA\n", + "\n", + "The framework of Fermionic QAOA (FQAOA) covers the Quantum Annealing (QA) framework [1]. In this note, we demonstrate that QA with FQAOA works for constrained combinatorial optimisation problems in practice and compare its performance with QA with conventional QAOA [2]." + ] + }, + { + "cell_type": "markdown", + "id": "25e5ec42-907e-41d2-9170-78e153af1ecd", + "metadata": {}, + "source": [ + "### FQAOA Ansatz for QA\n", + "FQAOA supports a discretised form of quantum annealing.\n", + "Quantum annealing starts with a mixer Hamiltonian ground state and gradually evolves to a cost Hamiltonian ground state.\n", + "If the transformation can be performed slowly to infinity, it is guaranteed to reach the exact ground state of the cost Hamiltonian.\n", + "In practice, the transformation is performed over a finite time and we want to prepare the ground state with some high probability.\n", + "\n", + "The approximated ground state obtained by QA are as follows:\n", + "$$|\\psi(T)\\rangle = {\\cal T}\\exp\\left\\{ -i\\int_0^T \\left[\\left(1-\\frac{t}{T}\\right)\\hat{\\cal H}_M+\\frac{t}{T}\\hat{\\cal H}_C\\right] dt\\right\\}\\hat{U}_{\\rm init}|{\\rm vac}\\rangle,$$\n", + "where the cost $\\hat{\\cal H}_C$ and mixer $\\hat{\\cal H}_M$ Hamiltonians, and initial state preparation unitary $\\hat{U}_{\\rm init}$ are given in the notebook `16-FQAOA_examples`. $T$ is annealing time and $\\cal T$ is time ordering product for $t$.\n", + "\n", + "The $|\\psi(T)\\rangle$ is approximated in the following form for calculation in quantum circuits [1, 2]:\n", + "$$|\\psi(T)\\rangle\\sim|\\psi_p({\\boldsymbol \\gamma}^{(0)}, {\\boldsymbol \\beta}^{(0)})\\rangle \n", + "= \\left[\\prod_{j=1}^pU(\\hat{\\cal H}_M,\\beta_j^{(0)}){U}(\\hat{\\cal H}_C,\\gamma_j^{(0)})\\right]\\hat{U}_{\\rm init}|{\\rm vac}\\rangle,$$\n", + "with\n", + "\\begin{eqnarray}\n", + " \\gamma_j^{(0)} &=& \\frac{2j-1}{2p}\\Delta t, \\\\\n", + " \\beta_j^{(0)} &=& \\left(1-\\frac{2j-1}{2p}\\right)\\Delta t,\n", + "\\end{eqnarray}\n", + "where $\\Delta t$ is the unit of descretized annealing time, as $T=p\\Delta t$.\n", + "\n", + "In the FQAOA ansatz, the following constraints can be imposed on any integer $M$ smaller than the number of qubits $N$ as:\n", + "$$\\sum_{i=1}^{N} \\hat{n}_i|\\psi_p({\\boldsymbol \\gamma^{(0)}}, {\\boldsymbol \\beta}^{(0)})\\rangle = M|\\psi_p({\\boldsymbol \\gamma^{(0)}}, {\\boldsymbol \\beta}^{(0)})\\rangle,$$\n", + "where $\\hat{n}_i = \\hat{c}^\\dagger_i\\hat{c}_i$ is number operator and $\\hat{c}_i^\\dagger (\\hat{c}_i)$ is creation (annihilation) operator of fermion at $i$-th site.\n", + "\n", + "The FQAOA ansatz is also improved from $|\\psi_p({\\boldsymbol \\gamma}^{(0)}, {\\boldsymbol \\beta}^{(0)})\\rangle$ by setting ${\\boldsymbol \\gamma}^{(0)}, {\\boldsymbol \\beta}^{(0)}$ as initial parameters and running FQAOA. Thus, the performance of the FQAOA framework is guaranteed by QA." + ] + }, + { + "cell_type": "markdown", + "id": "f7eb209f-387b-4987-b642-e76f61168cf1", + "metadata": {}, + "source": [ + "### QA using FQAOA Ansatz" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "11087210-d89c-4b4d-a85a-576a1faad80f", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# QA using FQAOA\n", + "fqaoa_cost_list = []\n", + "fqaoa_ip_values = range(1, 11)\n", + "fqaoa_dt = 0.1\n", + "\n", + "for ip in fqaoa_ip_values:\n", + " fqaoa = FQAOA(device)\n", + " fqaoa.set_circuit_properties(p=ip, param_type='annealing', init_type='ramp', annealing_time=fqaoa_dt*ip)\n", + " fqaoa.set_classical_optimizer(maxiter=0)\n", + " fqaoa.fermi_compile(problem = problem, n_fermions = budget)\n", + " fqaoa.optimize()\n", + " fqaoa_cost_list.append(fqaoa.result.optimized['cost'])" + ] + }, + { + "cell_type": "markdown", + "id": "4c4dd7b9-0389-4689-a4fd-52917e6d7b06", + "metadata": {}, + "source": [ + "### QA using Conventional QAOA Ansatz" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0ee8df0b-e25d-4f9b-8304-1bdff0acb64b", + "metadata": {}, + "outputs": [], + "source": [ + "# QA using QAOA\n", + "qaoa_cost_list = []\n", + "qaoa_ip_values = range(1, 101)\n", + "qaoa_dt = 0.01\n", + "\n", + "for ip in qaoa_ip_values:\n", + " qaoa = QAOA(device)\n", + " qaoa.set_circuit_properties(p=ip, param_type='annealing', init_type='ramp', annealing_time=qaoa_dt*ip)\n", + " qaoa.set_classical_optimizer(maxiter=0)\n", + " qaoa.compile(problem = problem)\n", + " qaoa.optimize()\n", + " qaoa_cost_list.append(qaoa.result.optimized['cost'])" + ] + }, + { + "cell_type": "markdown", + "id": "ef9f898f-32fa-471d-8fb3-3d97a7b1b0d7", + "metadata": {}, + "source": [ + "## Performance Evaluation of QA with FQAOA" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "51385cb6-0205-48ce-994f-5f4bbd6ce2af", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting costs against annealing time\n", + "fqaoa_annealing_times = [ip * 0.1 for ip in fqaoa_ip_values]\n", + "qaoa_annealing_times = [ip * 0.01 for ip in qaoa_ip_values]\n", + "\n", + "# Plotting the results\n", + "plt.plot(fqaoa_annealing_times, fqaoa_cost_list, marker='o', label='FQAOA')\n", + "plt.plot(qaoa_annealing_times, qaoa_cost_list, marker='x', label='QAOA')\n", + "plt.xlabel('Annealing Time $T$')\n", + "plt.ylabel('Cost')\n", + "plt.title(r'Quantum Annealing Cost vs. Annealing Time')\n", + "plt.xlim(0, 1)\n", + "plt.grid(True)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "94ed2180-28b8-4a47-937c-90bd6ab4eadd", + "metadata": {}, + "source": [ + "# FQAOA with Fourier Parametrization\n", + "\n", + "To appreciate the benefits of the Fourier parametrisation, let's compare the case $p=1$ using `StandardParams` with the case $q = 1, p=2$ using `FourierParams`. Here, we are optimising over the same total number of parameters, however the `FourierParams` ought to be capturing features of a more expressive circuit. \n", + "\n", + "Details of the Fourier parametrization are given in Ref [3] and in the Notebook `05 - QAOA circuit with advanced circuit parameterizations`." + ] + }, + { + "cell_type": "markdown", + "id": "a147232a-3a4f-47d3-82a7-db8757bfa0ec", + "metadata": {}, + "source": [ + "### Fourier Parametrization" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b359fc8d-8f9b-4396-806e-d7f2c6e1ddc9", + "metadata": {}, + "outputs": [], + "source": [ + "p_fourier = 2\n", + "q = 1\n", + "\n", + "fq_fourier = FQAOA()\n", + "fq_fourier.set_circuit_properties(p=p_fourier, param_type='fourier', init_type='ramp', q=q)\n", + "fq_fourier.fermi_compile(problem = problem, n_fermions=budget)\n", + "fq_fourier.optimize()" + ] + }, + { + "cell_type": "markdown", + "id": "8ecbdf29-4cc3-42b4-827a-cdd6b4069666", + "metadata": {}, + "source": [ + "### Standard Parametrization" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ffb9aead-90b6-4430-b1ff-2045f2c017b4", + "metadata": {}, + "outputs": [], + "source": [ + "p_list = [1, 2]\n", + "fq_std_list = []\n", + "for p in p_list:\n", + " fq_std = FQAOA()\n", + " fq_std.set_circuit_properties(p=p)\n", + " fq_std.fermi_compile(problem = problem, n_fermions=budget)\n", + " fq_std.optimize()\n", + " fq_std_list.append(fq_std)" + ] + }, + { + "cell_type": "markdown", + "id": "66b12bb6-db7f-4caf-83b3-216151cb1d88", + "metadata": {}, + "source": [ + "## Performance Evaluation of FQAOA with Fourier Parametrization" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "104e1c25-d674-4813-b706-f899b8fd23c6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(10,7))\n", + "label_list = [f'Fourier params (p={p_fourier}, q={q}) optimization', \n", + " f'Stadard params (p={p_list[0]}) optimization',]\n", + "\n", + "for i, fqaoa in enumerate([fq_fourier, fq_std_list[0]]):\n", + " yvalue = fqaoa.result.intermediate['cost']\n", + " plt.plot(yvalue,label=label_list[i],ls='-.')\n", + "\n", + "plt.xlabel('Number of function evaluations')\n", + "plt.ylabel('cost')\n", + "plt.legend()\n", + "plt.title('Comparison of FQAOA performance between Fourier and Standard Parameterizations')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8106c098-1fe7-43ad-b276-8aeeb57f0e7d", + "metadata": {}, + "source": [ + "# References\n", + "[1] T. Yoshioka, K. Sasada, Y. Nakano, and K. Fujii, [Phys. Rev. Research 5, 023071 (2023).](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071).\\\n", + "[2] E. Farhi, J. Goldston, S. Gutmann, and M. Sipser, [arXiv:quant-ph/0001106](https://arxiv.org/pdf/quant-ph/0001106).\\\n", + "[3] L. Zhou, S. Wang, S. Choi, H. Pichler, and M. D. Lukin, [Phys. Rev. X 10, 021067 (2020).](https://journals.aps.org/prx/pdf/10.1103/PhysRevX.10.021067)" + ] + } + ], + "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": 5 +} diff --git a/examples/17_demonstration_of_quantum_annealing_with_FQAOA.ipynb b/examples/17_demonstration_of_quantum_annealing_with_FQAOA.ipynb deleted file mode 100644 index 3dabb39d5..000000000 --- a/examples/17_demonstration_of_quantum_annealing_with_FQAOA.ipynb +++ /dev/null @@ -1,293 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "c5de313a", - "metadata": {}, - "source": [ - "# 17 - Demonstration of Quantum Annealing with FQAOA\n", - "\n", - "The framework of Fermionic QAOA (FQAOA) covers the Quantum Annealing (QA) framework [1]. In this note, we demonstrate that QA with FQAOA works for constrained combinatorial optimisation problems in practice and compare its performance with QA with conventional QAOA [2].\n", - "\n", - "## FQAOA Ansatz for QA\n", - "FQAOA supports a discretised form of quantum annealing.\n", - "Quantum annealing starts with a mixer Hamiltonian ground state and gradually evolves to a cost Hamiltonian ground state.\n", - "If the transformation can be performed slowly to infinity, it is guaranteed to reach the exact ground state of the cost Hamiltonian.\n", - "In practice, the transformation is performed over a finite time and we want to prepare the ground state with some high probability.\n", - "\n", - "The approximated ground state obtained by QA are as follows:\n", - "$$|\\psi(T)\\rangle = {\\cal T}\\exp\\left\\{ -i\\int_0^T \\left[\\left(1-\\frac{t}{T}\\right)\\hat{\\cal H}_M+\\frac{t}{T}\\hat{\\cal H}_C\\right] dt\\right\\}\\hat{U}_{\\rm init}|{\\rm vac}\\rangle,$$\n", - "where the cost $\\hat{\\cal H}_C$ and mixer $\\hat{\\cal H}_M$ Hamiltonians, and initial state preparation unitary $\\hat{U}_{\\rm init}$ are given in the notebook (16_FQAOA_examples.ipynb)[./16_FQAOA_examples.ipynb]. $T$ is annealing time and $\\cal T$ is time ordering product for $t$.\n", - "\n", - "The $|\\psi(T)\\rangle$ is approximated in the following form for calculation in quantum circuits [1, 2]:\n", - "$$|\\psi(T)\\rangle\\sim|\\psi_p({\\boldsymbol \\gamma}^{(0)}, {\\boldsymbol \\beta}^{(0)})\\rangle \n", - "= \\left[\\prod_{j=1}^pU(\\hat{\\cal H}_M,\\beta_j^{(0)}){U}(\\hat{\\cal H}_C,\\gamma_j^{(0)})\\right]\\hat{U}_{\\rm init}|{\\rm vac}\\rangle,$$\n", - "with\n", - "\\begin{eqnarray}\n", - " \\gamma_j^{(0)} &=& \\frac{2j-1}{2p}\\Delta t, \\\\\n", - " \\beta_j^{(0)} &=& \\left(1-\\frac{2j-1}{2p}\\right)\\Delta t,\n", - "\\end{eqnarray}\n", - "where $\\Delta t$ is the unit of descretized annealing time, as $T=p\\Delta t$.\n", - "\n", - "In the FQAOA ansatz, the following constraints can be imposed on any integer $M$ smaller than the number of qubits $N$ as:\n", - "$$\\sum_{i=1}^{N} \\hat{n}_i|\\psi_p({\\boldsymbol \\gamma^{(0)}}, {\\boldsymbol \\beta}^{(0)})\\rangle = M|\\psi_p({\\boldsymbol \\gamma^{(0)}}, {\\boldsymbol \\beta}^{(0)})\\rangle,$$\n", - "where $\\hat{n}_i = \\hat{c}^\\dagger_i\\hat{c}_i$ is number operator and $\\hat{c}_i^\\dagger (\\hat{c}_i)$ is creation (annihilation) operator of fermion at $i$-th site.\n", - "\n", - "The FQAOA ansatz is also improved from $|\\psi_p({\\boldsymbol \\gamma}^{(0)}, {\\boldsymbol \\beta}^{(0)})\\rangle$ by setting ${\\boldsymbol \\gamma}^{(0)}, {\\boldsymbol \\beta}^{(0)}$ as initial parameters and running FQAOA. Thus, the performance of the FQAOA framework is guaranteed by QA.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "d3e2b171-0013-4e2e-9801-8a6a58d50370", - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib notebook\n", - "%matplotlib inline\n", - "\n", - "# Import the libraries needed to employ the QAOA and FQAOA quantum algorithm using OpenQAOA\n", - "from openqaoa import FQAOA\n", - "from openqaoa import QAOA\n", - "\n", - "# method to covnert a docplex model to a qubo problem\n", - "from openqaoa.problems import PortfolioOptimization\n", - "from openqaoa.backends import create_device\n", - "from openqaoa.algorithms.fqaoa import fqaoa_utils\n", - "\n", - "# Import external libraries to present an manipulate the data\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Indicate the device, this case is a local simulator\n", - "device = create_device('local', 'vectorized')" - ] - }, - { - "cell_type": "markdown", - "id": "8d47957a-251f-4206-8199-2c551713a754", - "metadata": {}, - "source": [ - "In the following, the [portfolio optimization problem](https://en.wikipedia.org/wiki/Portfolio_optimization) is taken as a constrained quadratic formal optimisation problem.\n", - "In this case, $N$ and $M$ in the equation are the number of the assets and the budget, respectively." - ] - }, - { - "cell_type": "markdown", - "id": "bb6a05c9-82f7-431b-b60f-de61cd71d3cf", - "metadata": {}, - "source": [ - "## Create a Problem Instance\n", - "\n", - "To simplify the problem, it is used a random function to generate the predictions the expected return for 10 assets during 15 days as in [6]. " - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "06460e0b-e03f-46f3-8008-1ef9688f3e57", - "metadata": {}, - "outputs": [], - "source": [ - "# generate the input data for portfolio optimization\n", - "num_assets = 4 # number of assets\n", - "budget = 2 # budget constraint value\n", - "num_days = 15 # number of days\n", - "seed = 1 # seed of random number\n", - "mu, sigma, hist_exp = fqaoa_utils.generate_random_portfolio_data(num_assets, num_days, seed)\n", - "problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo" - ] - }, - { - "cell_type": "markdown", - "id": "f7eb209f-387b-4987-b642-e76f61168cf1", - "metadata": {}, - "source": [ - "## Execute Quantum Annealing\n", - "\n", - "Here, a fermionic mixer Hamiltonian $\\hat{\\cal H}_M$ on cyclic lattice determines its ground state as the initial state $\\hat{U}_{\\rm init}|\\rm vac\\rangle$ and its mixer $U(\\hat{\\cal H}_M, \\beta)$." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "11087210-d89c-4b4d-a85a-576a1faad80f", - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "# QA using FQAOA\n", - "fqaoa_cost_list = []\n", - "fqaoa_ip_values = range(1, 21)\n", - "fqaoa_dt = 0.1\n", - "\n", - "for ip in fqaoa_ip_values:\n", - " fqaoa = FQAOA(device)\n", - " fqaoa.set_circuit_properties(p=ip, param_type='annealing', init_type='ramp', annealing_time=fqaoa_dt*ip)\n", - " fqaoa.set_classical_optimizer(maxiter=0)\n", - " fqaoa.fermi_compile(problem = problem, n_fermions = budget)\n", - " fqaoa.optimize()\n", - " fqaoa_cost_list.append(fqaoa.result.optimized['cost'])" - ] - }, - { - "cell_type": "markdown", - "id": "4c4dd7b9-0389-4689-a4fd-52917e6d7b06", - "metadata": {}, - "source": [ - "Here, the conventional X-mixer Hamiltonian $H_M$ determines its ground state as the initial state and its unitary transformation $\\exp(-i\\beta\\hat{\\cal H}_M)$ as the mixer." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "0ee8df0b-e25d-4f9b-8304-1bdff0acb64b", - "metadata": {}, - "outputs": [], - "source": [ - "# QA using QAOA\n", - "qaoa_cost_list = []\n", - "qaoa_ip_values = range(1, 101)\n", - "qaoa_dt = 0.01\n", - "\n", - "for ip in qaoa_ip_values:\n", - " qaoa = QAOA(device)\n", - " qaoa.set_circuit_properties(p=ip, param_type='annealing', init_type='ramp', annealing_time=qaoa_dt*ip)\n", - " qaoa.set_classical_optimizer(maxiter=0)\n", - " qaoa.compile(problem = problem)\n", - " qaoa.optimize()\n", - " qaoa_cost_list.append(qaoa.result.optimized['cost'])" - ] - }, - { - "cell_type": "markdown", - "id": "ef9f898f-32fa-471d-8fb3-3d97a7b1b0d7", - "metadata": {}, - "source": [ - "## Plotting the Results and Comparison" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "d2e67f5f-b0d7-4db1-9973-9dc8013f0aa9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plotting the FQAOA results\n", - "plt.plot(fqaoa_ip_values, fqaoa_cost_list, marker='o')\n", - "plt.xlabel('p')\n", - "plt.ylabel('Cost')\n", - "plt.xlim(0, 20)\n", - "plt.grid(True)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "56b60100-6588-4353-9d7a-f19645693030", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plotting the QAOA results\n", - "plt.plot(qaoa_ip_values, qaoa_cost_list, marker='x', label='QAOA', color='C1')\n", - "plt.xlabel('p')\n", - "plt.ylabel('Cost')\n", - "plt.xlim(0, 20)\n", - "plt.ylim(92.5,107.5)\n", - "plt.grid(True)\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "51385cb6-0205-48ce-994f-5f4bbd6ce2af", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plotting costs against annealing time\n", - "fqaoa_annealing_times = [ip * 0.1 for ip in fqaoa_ip_values]\n", - "qaoa_annealing_times = [ip * 0.01 for ip in qaoa_ip_values]\n", - "\n", - "# Plotting the results\n", - "plt.plot(fqaoa_annealing_times, fqaoa_cost_list, marker='o', label='FQAOA')\n", - "plt.plot(qaoa_annealing_times, qaoa_cost_list, marker='x', label='QAOA')\n", - "plt.xlabel('Annealing Time $T$')\n", - "plt.ylabel('Cost')\n", - "plt.title(r'Quantum Annealing Cost vs. Annealing Time')\n", - "plt.xlim(0, 1)\n", - "plt.grid(True)\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "8106c098-1fe7-43ad-b276-8aeeb57f0e7d", - "metadata": {}, - "source": [ - "# References\n", - "[1] T. Yoshioka, K. Sasada, Y. Nakano, and K. Fujii, [Phys. Rev. Research 5, 023071 (2023).](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071), [arXiv: 2301.10756 [quant-ph]](https://arxiv.org/pdf/2301.10756).\\\n", - "[2] E. Farhi, J. Goldston, S. Gutmann, M. Sipser, [arXiv:quant-ph/0001106](https://arxiv.org/pdf/quant-ph/0001106)." - ] - } - ], - "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": 5 -} From 6d2b9b5301ed24ca79549575848fdab873ccf429 Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Wed, 4 Sep 2024 10:06:48 +0900 Subject: [PATCH 12/26] Fix typos and minor issues based on review comments --- docs/source/index.rst | 7 +- examples/16_FQAOA_example.ipynb | 591 ++++++++++++++ examples/16_FQAOA_examples.ipynb | 764 ------------------ .../17_FQAOA_advanced_parameterization.ipynb | 133 +-- .../openqaoa/algorithms/fqaoa/fqaoa_utils.py | 8 +- .../algorithms/fqaoa/fqaoa_workflow.py | 98 ++- src/openqaoa-core/tests/test_fqaoa.py | 159 ++-- src/openqaoa-core/tests/test_workflows.py | 229 +++--- 8 files changed, 871 insertions(+), 1118 deletions(-) create mode 100644 examples/16_FQAOA_example.ipynb delete mode 100644 examples/16_FQAOA_examples.ipynb diff --git a/docs/source/index.rst b/docs/source/index.rst index 7531a6a10..031d8d9d8 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -178,10 +178,10 @@ Your first FQAOA workflow from openqaoa import FQAOA fqaoa = FQAOA() - fqaoa.fermi_compile(qubo_problem, n_fermions) + fqaoa.compile(qubo_problem, n_fermions) fqaoa.optimize() -FQAOA intrinsically imposes a hard constraint where the hamming wieght is equal to n_fermions. +FQAOA intrinsically imposes a hard constraint where the hamming weight is equal to n_fermions. Factory mode ------------ @@ -317,7 +317,8 @@ Contents notebooks/14_qaoa_benchmark.ipynb notebooks/X_dumping_data.ipynb notebooks/15_Zero_Noise_Extrapolation.ipynb - notebooks/16_FQAOA_examples.ipynb + notebooks/16_FQAOA_example.ipynb + notebooks/17_FQAOA_advanced_parametrization.ipynb Indices and tables ================== diff --git a/examples/16_FQAOA_example.ipynb b/examples/16_FQAOA_example.ipynb new file mode 100644 index 000000000..31c6b79e1 --- /dev/null +++ b/examples/16_FQAOA_example.ipynb @@ -0,0 +1,591 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c5de313a", + "metadata": {}, + "source": [ + "# 16 - Fermionic QAOA (FQAOA)\n", + "\n", + "This notebook provides a brief introduction to Fermionic QAOA (FQAOA). \n", + "It shows how this technique is implemented in the OpenQAOA workflow by solving the constrained quadratic optimization problem, an NP-hard problem.\n", + "\n", + "## A brief introduction\n", + "\n", + "We present an implementation of a novel algorithm designed for solving combinatorial optimization problems with constraints, utilizing the principles of quantum computing. The algorithm, known as the FQAOA [[1](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071)\n", + ", [2](https://arxiv.org/pdf/2312.04710)]\n", + ", introduces a significant enhancement over traditional methods by leveraging fermion particle number preservation. This intrinsic property allows the algorithm to enforce constraints naturally throughout the optimization process, addressing a critical challenge in many combinatorial problems.\n", + "\n", + "### Key Features\n", + "- Constraint Handling: In contrast to conventional approaches, which treat constraints as soft constraints in the cost function, FQAOA enforces constraints intrinsically by preserving fermion particle numbers, thereby enhancing the overall performance of the optimization algorithm.\n", + "\n", + "- Design of FQAOA Ansatz: In this algorithm,\n", + "the mixer is designed so that any classical state can be reached by its multiple actions.\n", + "The initial state is set to a ground state of the mixer Hamiltonian satisfying the constraints of the problem.\n", + "\n", + "- Adiabatic Evolution: FQAOA effectively reduces to quantum adiabatic computation in the large limit of circuit depth, $p$, offering improved performance even for shallow circuits by optimizing parameters starting from fixed angles determined by Trotterized quantum adiabatic evolution.\n", + "\n", + "- Performance Advantage: Extensive numerical simulations demonstrate that FQAOA offers substantial performance benefits over existing methods, particularly in portfolio optimization problems.\n", + "\n", + "- Broad Applicability: The Hamiltonian design guideline benefits QAOA and extends to other algorithms like Grover adaptive search and quantum phase estimation, making it a versatile tool for solving constrained combinatorial optimization problems.\n", + "\n", + "This notebook describes the implementation of FQAOA, illustrates its application through various examples, and provides insight into FQAOA's superior performance in constrained combinatorial optimization tasks.\n", + "\n", + "### Quadratic Constrained Binary Optimization Problems\n", + "The constrained combinatorial optimization problem for a polynomial cost function　$C_{\\boldsymbol x}$ covered here can be written in the following form：\n", + "$${\\boldsymbol x}^* = \\arg \\min_{\\boldsymbol x} C_{\\boldsymbol x}\\qquad {\\rm s.t.} \\quad\\sum_{i=1}^{N} x_i = M,$$\n", + "with bit string ${\\boldsymbol x}\\in \\{0,1\\}^N$, where ${\\boldsymbol x}^*$ is the optimal solution.\n", + "This problem can be replaced by the minimum eigenvalue problem in the following steps.\n", + "\n", + "1. map the cost function $C_{\\boldsymbol x}$ to the cost Hamiltonian $\\hat{\\cal H}_C$ by $x_i\\rightarrow \\hat{n}_i$:\n", + "\\begin{eqnarray}\n", + "C_{\\boldsymbol x} &=& \\sum_i \\mu_i x_{i}+\\sum_{i,j} \\sigma_{i,j} x_{i}x_{j}\n", + "&\\quad\\mapsto\\quad&\\hat{\\cal H}_C=\\sum_i \\mu_i \\hat{n}_{i}+\\sum_{i,j} \\sigma_{i,j} \\hat{n}_{i_1}\\hat{n}_{i_2},\n", + "\\end{eqnarray}\n", + "where $\\hat{n}_i = \\hat{c}^\\dagger_i\\hat{c}_i$ is number operator and $\\hat{c}_i^\\dagger (\\hat{c}_i)$ is creation (annihilation) operator of fermion at $i$-th site.\n", + "\n", + "2. formulate eigenvalue problems for combinatorial optimization problem under the constraint:\n", + "\\begin{eqnarray}\n", + "\\hat{\\cal H}_C|x_1x_2\\cdots x_N\\rangle &=& C_{\\boldsymbol x}|x_1x_2\\cdots x_N\\rangle,\\\\\n", + "\\sum_{i=1}^{N} \\hat{n}_i|x_1x_2\\cdots x_N\\rangle &=& M|x_1x_2\\cdots x_N\\rangle,\n", + "\\end{eqnarray}\n", + "where $|x_1x_2\\cdots x_N\\rangle=(\\hat{c}^\\dagger_1)^{x_1}(\\hat{c}^\\dagger_2)^{x_2}\\cdots (\\hat{c}^\\dagger_N)^{x_N}|{\\rm vac}\\rangle$ is fermionic basis state and $|\\rm vac\\rangle$ is vacuum satisfying $\\hat{c}_i|\\rm vac\\rangle=0$.\n", + "\n", + "3. optimize FQAOA ansatz:\n", + "$$|\\psi_p({\\boldsymbol \\gamma}^*, {\\boldsymbol \\beta}^*)\\rangle \n", + "= \\left[\\prod_{j=1}^pU(\\hat{\\cal H}_M,\\beta_j^*){U}(\\hat{\\cal H}_C,\\gamma_j^*)\\right]\\hat{U}_{\\rm init}|{\\rm vac}\\rangle\n", + "\\qquad {\\rm by}\\quad\n", + "C_p({\\boldsymbol \\gamma}^*, {\\boldsymbol \\beta}^*)=\\min_{{\\boldsymbol \\gamma}, {\\boldsymbol \\beta}}C_p({\\boldsymbol \\gamma},{\\boldsymbol \\beta}),$$\n", + "$$\\qquad{\\rm where \\quad}C_p({\\boldsymbol \\gamma}, {\\boldsymbol \\beta}) = \\langle\\psi_p({\\boldsymbol \\gamma}, {\\boldsymbol \\beta})|\\hat{\\cal H}_C|\\psi_p({\\boldsymbol \\gamma}, {\\boldsymbol \\beta})\\rangle.$$\n", + "The variational parameters $({\\boldsymbol \\gamma}^*, {\\boldsymbol \\beta}^*)$ give the lowest cost value at QAOA level $p$.\n", + "\n", + "\n", + "### One-Dimensional Mixer Hamiltonian\n", + "\n", + "The FQAOA implemented on OpenQAOA employs mixer Hamiltonians on one-dimensional lattices. The main features of this computational model are summarized based on the study [[2]](https://arxiv.org/pdf/2312.04710):\n", + "\n", + "- Utilises a mixer Hamiltonian on a one-dimensional lattice dedicated to combinatorial optimization problems with equality constraints of the same coefficients.\n", + "\n", + "- Reduced Gate Operations: The new mixer Hamiltonian significantly reduces the number of gate operations in quantum circuits compared to previous studies [[1]](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071), thus improving computational efficiency.\n", + "\n", + "- Noise suppression: as demonstrated in a 16-qubit trapped-ion quantum computer on Amazon Braket, the proposed mixer Hamiltonian effectively suppresses noise and improves algorithm performance.\n", + "\n", + "As these features enhance the performance and reliability of FQAOA for solving constrained combinatorial optimization problems, we focus on FQAOA with one-dimensional mixer Hamiltonians.\n", + "\n", + "The specific mixer Hamiltonian $\\hat{\\cal H}_M$ on cyclic lattice to be implemented in OpenQAOA are as follow:\n", + "\n", + "\\begin{eqnarray}\n", + "\\hat{\\cal H}_M &=& t\\sum_{i=1}^{N-1} (\\hat{c}^\\dagger_i\\hat{c}_{i+1}+\\hat{c}^\\dagger_{i+1}\\hat{c}_i)-t(-1)^{M}(\\hat{c}^\\dagger_N\\hat{c}_{1}+\\hat{c}^\\dagger_{1}\\hat{c}_N).\n", + "\\end{eqnarray}\n", + "These Hamiltonians can be diagonalized as:\n", + "$$\\hat{\\cal H}_M=\\sum_{i=1}^{N}\\varepsilon_i\\hat{\\gamma}_i^\\dagger\\hat{\\gamma}_i \\qquad {\\rm with} \\quad\n", + "\\hat{\\gamma}_i^\\dagger = \\sum_{j=1}^N[\\phi_0]_{i,j}\\hat{c}^\\dagger_j,$$\n", + "where $[\\phi_0]$ is the unitary matrix used for the diagonalization and $\\varepsilon_i$ is eigenvalue.\n", + "The formulation and validation of the model on cyclic lattice are detailed in the study [[2]](https://arxiv.org/pdf/2312.04710).\n", + "\n", + "### Initial State and Mixer for FQAOA\n", + "\n", + "We describe the specific calculation model utilized for our implementation of the FQAOA on cyclic lattice. \n", + "The initial state preparation unitary $\\hat{U}_{\\rm init}$ and the mixer $\\hat{U}_M$ used to implement the FQAOA are shown below.\n", + "\n", + "- initial state preparation unitary $\\hat{U}_{\\rm init}$ on cyclic lattice:\n", + "$$|\\phi_0\\rangle=\\hat{U}_{\\rm init}|{\\rm vac}\\rangle=\\left(\\prod_{i=1}^{M}\\hat{\\gamma}_i^\\dagger\\right)|{\\rm vac}\\rangle,\n", + "\\qquad{\\rm with}\\quad \\hat{U}_{\\rm init}=\\prod_{i=1}^{M}\\left(\\sum_{j=1}^N[\\phi_0]_{i,j}\\hat{c}^\\dagger_j\\right),$$\n", + "where $M$ is the number of fermions and $i$ indexes the eigenvalues $\\varepsilon_i$ in ascending order.\n", + "The implementation of the initial state preparation unitary on quantum circuit are shown in Refs. [[1](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071),[2](https://arxiv.org/pdf/2312.04710),[3](https://arxiv.org/pdf/1711.05395)].\n", + "\n", + "- mixing unitary $U(\\hat{\\cal H}_M, \\beta)$ on cyclic lattice:\n", + "\\begin{eqnarray}\n", + "U(\\hat{\\cal H}_M, \\beta) &\\sim&\n", + "\\exp\\left[i\\beta t(-1)^M\\left(\\hat{c}^{\\dagger}_{ND}\\hat{c}_{1}+\\hat{c}^{\\dagger}_{1}\\hat{c}_{ND}\\right)\\right]\n", + "\\prod_{i\\ {\\rm even}}\\exp\\left[-i\\beta t\\left(\\hat{c}^{\\dagger}_i\\hat{c}_{i+1}+\\hat{c}^{\\dagger}_{i+1}\\hat{c}_{i}\\right)\\right]\n", + "\\prod_{i\\ {\\rm odd}}\\exp\\left[-i\\beta t\\left(\\hat{c}^{\\dagger}_i\\hat{c}_{i+1}+\\hat{c}^{\\dagger}_{i+1}\\hat{c}_{i}\\right)\\right],\n", + "\\end{eqnarray}\n", + "where the approximation by Trotter decomposition is applied, as certain hopping terms are non-commutative.\n", + "The implementation of the mixed unitary indicated on the right-hand side on quantum circuits is given in Refs. [[1](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071),\n", + "[2](https://arxiv.org/pdf/2312.04710), [4](https://arxiv.org/pdf/1709.03489), [5](https://arxiv.org/pdf/1904.09314)]." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d3e2b171-0013-4e2e-9801-8a6a58d50370", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib notebook\n", + "%matplotlib inline\n", + "\n", + "# Import the libraries needed to employ the QAOA and FQAOA quantum algorithm using OpenQAOA\n", + "from openqaoa import FQAOA\n", + "from openqaoa import QAOA\n", + "\n", + "# method to covnert a docplex model to a qubo problem\n", + "from openqaoa.problems import PortfolioOptimization\n", + "from openqaoa.backends import create_device\n", + "from openqaoa.utilities import bitstring_energy\n", + "\n", + "# Import external libraries to present an manipulate the data\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "8d47957a-251f-4206-8199-2c551713a754", + "metadata": {}, + "source": [ + "## Portfolio Optimization\n", + "\n", + "In the following, the [portfolio optimization problem](https://en.wikipedia.org/wiki/Portfolio_optimization) is taken as a constrained quadratic formal optimisation problem.\n", + "\n", + "$$\\min_{x} : q {\\boldsymbol x}^{T} {\\boldsymbol \\sigma} {\\boldsymbol x}-{\\boldsymbol\\mu}^{T} {\\boldsymbol x},\\qquad {\\rm s.t.} \\quad\\sum_{i=1}^{N} x_i = M,$$\n", + "\n", + "where:\n", + "- $N$: number of decision variables,\n", + "- ${\\boldsymbol x} \\in\\{0,1\\}^{N}$: vector of binary decision variables,\n", + "- ${\\boldsymbol \\mu} \\in R^{n}$: vector coefficients for the linear term,\n", + "- ${\\boldsymbol \\sigma} \\in R^{n \\times n}$: symmetric positive semidefinite matrix for quadratic term,\n", + "- $q$: quadratic term coefficient,\n", + "- $M$: constraint on the sum of decision variables." + ] + }, + { + "cell_type": "markdown", + "id": "bb6a05c9-82f7-431b-b60f-de61cd71d3cf", + "metadata": {}, + "source": [ + "Start by creating an instance of the portfolio optimisation problem, using the `random_instance` method of `the PortfolioOptimisation` class." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0efc6710-2cfe-4a0d-bf2f-f9ef3aed2ec5", + "metadata": {}, + "outputs": [], + "source": [ + "# create a problem instance for portfolio optimization\n", + "num_assets = 8 # number of assets\n", + "budget = 4 # budget constraint value\n", + "problem = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget, penalty = None).qubo" + ] + }, + { + "cell_type": "markdown", + "id": "fe2621d4", + "metadata": {}, + "source": [ + "## Solving the problem" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6d2328a6-88f2-4a85-964e-d00f036d044a", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# Indicate the device, this case is a local simulator\n", + "device = create_device('local', 'qiskit.statevector_simulator')" + ] + }, + { + "cell_type": "markdown", + "id": "f54c48a2", + "metadata": {}, + "source": [ + "The quantum algorithms consider the following properties: the qiskit's statevector_simulator backend with a `p` value equals to 2, with `ramp` initialization." + ] + }, + { + "cell_type": "markdown", + "id": "f7eb209f-387b-4987-b642-e76f61168cf1", + "metadata": {}, + "source": [ + "### FQAOA Optimization\n", + "\n", + "Here, a fermionic mixer Hamiltonian $\\hat{\\cal H}_M$ on cyclic lattice determines its ground state as the initial state $\\hat{U}_{\\rm init}|\\rm vac\\rangle$ and its mixer $U(\\hat{\\cal H}_M, \\beta)$." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "11087210-d89c-4b4d-a85a-576a1faad80f", + "metadata": {}, + "outputs": [], + "source": [ + "fqaoa = FQAOA(device)\n", + "fqaoa.set_circuit_properties(p=2)\n", + "fqaoa.compile(problem = problem, n_fermions = budget)\n", + "fqaoa.optimize()\n", + "fqaoa_results = fqaoa.result" + ] + }, + { + "cell_type": "markdown", + "id": "4c4dd7b9-0389-4689-a4fd-52917e6d7b06", + "metadata": {}, + "source": [ + "### Conventional QAOA Optimization\n", + "\n", + "Here, the conventional X-mixer Hamiltonian $H_M$ determines its ground state as the initial state and its unitary transformation $\\exp(-i\\beta\\hat{\\cal H}_M)$ as the mixer." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0ee8df0b-e25d-4f9b-8304-1bdff0acb64b", + "metadata": {}, + "outputs": [], + "source": [ + "qaoa = QAOA(device)\n", + "qaoa.set_circuit_properties(p=2)\n", + "qaoa.compile(problem = problem)\n", + "qaoa.optimize()\n", + "qaoa_results = qaoa.result" + ] + }, + { + "cell_type": "markdown", + "id": "5bf46716-6f89-4e00-bbae-cbe8a991055e", + "metadata": {}, + "source": [ + "### Performance Evaluation of FQAOA" + ] + }, + { + "cell_type": "markdown", + "id": "7571203b-664e-40c9-ba7d-209372403a80", + "metadata": {}, + "source": [ + "To evaluate the performance of FQAOA, we show expectation value of costs. \n", + "We define normalized costs by \n", + "$\\Delta C_{\\boldsymbol x}/W$ with $\\Delta C_{\\boldsymbol x} = (C_{\\boldsymbol x}-C_{\\rm min})$ and $W=(C_{\\rm max}-C_{\\rm min})$, where $C_{\\rm max}$ ($C_{\\rm min}$) is maximum (minimum) value of cost under the constraint." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "fe328715-f5ef-4422-aae4-a5e9dd745942", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(min C_x, max C_x) = ( -1.3716497056878048 2.5829135601546653 )\n" + ] + } + ], + "source": [ + "x_in_constraint = []\n", + "for i in range(2**num_assets):\n", + " bit = bin(i)[2:].zfill(num_assets)\n", + " cost = bitstring_energy(qaoa.cost_hamil, bit[::-1])\n", + " if bit.count('1') == budget:\n", + " x_in_constraint.append(cost)\n", + "C_max, C_min = max(x_in_constraint), min(x_in_constraint)\n", + "print('(min C_x, max C_x) = ', '(', C_min, C_max,')')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9b2c0b91-4de0-4362-9470-1d7a354e5418", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "label_list = ['QAOA', 'FQAOA']\n", + "opt_results_list, cost_list = [], []\n", + "exp_cost_dict = {}\n", + "for opt_result in [qaoa_results, fqaoa_results]:\n", + " opt_results_list.append(opt_result)\n", + " cost_list.append(opt_result.optimized['cost'])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5125af92-c141-4aae-813c-e2f27956d1c2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot cost history\n", + "for i, opt_result in enumerate([qaoa_results, fqaoa_results]):\n", + " cost = opt_result.intermediate['cost']\n", + " cost = [(cost[i]-C_min)/(C_max-C_min) for i in range(len(cost))]\n", + " plt.plot(cost, ls='--')\n", + "plt.title('Cost history')\n", + "plt.grid(True)\n", + "plt.xlabel('number of functions evaluations')\n", + "plt.ylabel(r'normalized cost, $\\langle \\Delta C_{\\boldsymbol{x}}/W \\rangle$')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9c6dda49-9fb0-4235-9a7d-8e6ba14ecebf", + "metadata": {}, + "source": [ + "### Performance Evaluation of FQAOA" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e620d83e-0a6c-433a-af44-1b7a04f0d491", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "expectation values of the costs.\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
method$\\langle C_{\\boldsymbol x} \\rangle$$\\langle \\Delta C_{\\boldsymbol x}\\rangle /W$
0QAOA6.9281242.098784
1FQAOA-0.5439820.209294
\n", + "
" + ], + "text/plain": [ + " method $\\langle C_{\\boldsymbol x} \\rangle$ \\\n", + "0 QAOA 6.928124 \n", + "1 FQAOA -0.543982 \n", + "\n", + " $\\langle \\Delta C_{\\boldsymbol x}\\rangle /W$ \n", + "0 2.098784 \n", + "1 0.209294 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# evaluate the expection values of the cost\n", + "exp_cost_dict['method'] = label_list\n", + "exp_cost_dict[r'$\\langle C_{\\boldsymbol x} \\rangle$'] = cost_list\n", + "exp_cost_dict[r'$\\langle \\Delta C_{\\boldsymbol x}\\rangle /W$'] = (np.array(cost_list)-C_min)/(C_max-C_min)\n", + "df = pd.DataFrame(exp_cost_dict)\n", + "\n", + "print(r'expectation values of the costs.')\n", + "display(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6373b123-b0d2-44db-a4d6-5d2ca44185d8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Comparison of methods for calculating the probability of finding the optimal solutions\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
bitstrings, $\\boldsymbol{x}$$C_{\\boldsymbol x}$$\\Delta C_{\\boldsymbol x}/W$Probability (QAOA)Probability (FQAOA)
011100001-1.3716500.0000000.0067340.015174
111101000-1.1936960.0450000.0070450.020652
210101001-1.0802950.0736750.0066680.227928
310110001-1.0792400.0739420.0056270.096106
411100100-0.9493030.1068000.0058120.016974
\n", + "
" + ], + "text/plain": [ + " bitstrings, $\\boldsymbol{x}$ $C_{\\boldsymbol x}$ \\\n", + "0 11100001 -1.371650 \n", + "1 11101000 -1.193696 \n", + "2 10101001 -1.080295 \n", + "3 10110001 -1.079240 \n", + "4 11100100 -0.949303 \n", + "\n", + " $\\Delta C_{\\boldsymbol x}/W$ Probability (QAOA) Probability (FQAOA) \n", + "0 0.000000 0.006734 0.015174 \n", + "1 0.045000 0.007045 0.020652 \n", + "2 0.073675 0.006668 0.227928 \n", + "3 0.073942 0.005627 0.096106 \n", + "4 0.106800 0.005812 0.016974 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Print the best 5 solutions\n", + "lowest_dict = opt_results_list[0].lowest_cost_bitstrings(5)\n", + "list1 = lowest_dict['bitstrings_energies']\n", + "normalized_cost = [(x - C_min) / (C_max - C_min) for x in list1]\n", + "qaoa_dict = {\n", + " r'bitstrings, $\\boldsymbol{x}$': lowest_dict['solutions_bitstrings'],\n", + " r'$C_{\\boldsymbol x}$': list1,\n", + " r'$\\Delta C_{\\boldsymbol x}/W$': normalized_cost,\n", + " f'Probability ({label_list[0]})': lowest_dict.pop('probabilities'),\n", + " f'Probability ({label_list[1]})': opt_results_list[1].lowest_cost_bitstrings(5)['probabilities']\n", + "}\n", + "df = pd.DataFrame(qaoa_dict)\n", + "print('Comparison of methods for calculating the probability of finding the optimal solutions')\n", + "display(df)" + ] + }, + { + "cell_type": "markdown", + "id": "8106c098-1fe7-43ad-b276-8aeeb57f0e7d", + "metadata": {}, + "source": [ + "# References\n", + "\n", + "[1] T. Yoshioka, K. Sasada, Y. Nakano, and K. Fujii, [Phys. Rev. Research 5, 023071 (2023).](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071), [arXiv:2301.10756 [quant-ph]](https://arxiv.org/pdf/2301.10756).\\\n", + "[2] T. Yoshioka, K. Sasada, Y. Nakano, and K. Fujii, [2023 IEEE International Conference on Quantum Computing and Engineering (QCE) 1, 300-306 (2023).](https://ieeexplore.ieee.org/document/10313662), [arXiv:2312.04710 [quant-ph]](https://arxiv.org/pdf/2312.04710).\\\n", + "[3] Z. Jiang, J. S. Kevin, K. Kechedzhi, V. N. Smelyanskiy, and S. Boixo, [Phys. Rev. Appl. 9, 044036 (2018).](https://journals.aps.org/prapplied/abstract/10.1103/PhysRevApplied.9.044036)[arXiv:1711.05395 [quant-ph]](https://arxiv.org/pdf/1711.05395).\\\n", + "[4] S. Hadfield, Z. Wang, B. O’Gorman, E. G. Rieffel, D. Venturelli, and R. Biswas, [algorithms 12, 34 (2019).](https://www.mdpi.com/1999-4893/12/2/34),[arXiv:1709.03489v2 [quant-ph]](https://arxiv.org/pdf/1709.03489).\\\n", + "[5] Z. Wang, N. C. Rubin, J. M. Dominy, and E. G. Rioeffel, [Phys. Rev. A 101, 012320 (2020).](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.101.012320),[arXiv:1904.09314v2 [quant-ph]](https://arxiv.org/pdf/1904.09314)." + ] + } + ], + "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": 5 +} diff --git a/examples/16_FQAOA_examples.ipynb b/examples/16_FQAOA_examples.ipynb deleted file mode 100644 index 805cfc6cc..000000000 --- a/examples/16_FQAOA_examples.ipynb +++ /dev/null @@ -1,764 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "c5de313a", - "metadata": {}, - "source": [ - "# 16 - Fermionic QAOA (FQAOA)\n", - "\n", - "This notebook provides a brief introduction to Fermionic QAOA (FQAOA). \n", - "It shows how this technique is implemented in the OpenQAOA workflow by solving the constrained quadratic optimization problem, an NP-hard problem.\n", - "\n", - "## A brief introduction\n", - "\n", - "We present an implementation of a novel algorithm designed for solving combinatorial optimization problems with constraints, utilizing the principles of quantum computing. The algorithm, known as the FQAOA [1, 2], introduces a significant enhancement over traditional methods by leveraging fermion particle number preservation. This intrinsic property allows the algorithm to enforce constraints naturally throughout the optimization process, addressing a critical challenge in many combinatorial problems.\n", - "\n", - "### Key Features\n", - "- Constraint Handling: In contrast to conventional approaches, which treat constraints as soft constraints in the cost function, FQAOA enforces constraints intrinsically by preserving fermion particle numbers, thereby enhancing the overall performance of the optimization algorithm.\n", - "\n", - "- Design of FQAOA Ansatz: In this algorithm,\n", - "the mixer is designed so that any classical state can be reached by its multiple actions.\n", - "The initial state is set to a ground state of the mixer Hamiltonian satisfying the constraints of the problem.\n", - "\n", - "- Adiabatic Evolution: FQAOA effectively reduces to quantum adiabatic computation in the large limit of circuit depth, $p$, offering improved performance even for shallow circuits by optimizing parameters starting from fixed angles determined by Trotterized quantum adiabatic evolution.\n", - "\n", - "- Performance Advantage: Extensive numerical simulations demonstrate that FQAOA offers substantial performance benefits over existing methods, particularly in portfolio optimization problems.\n", - "\n", - "- Broad Applicability: The Hamiltonian design guideline benefits QAOA and extends to other algorithms like Grover adaptive search and quantum phase estimation, making it a versatile tool for solving constrained combinatorial optimization problems.\n", - "\n", - "This notebook describes the implementation of FQAOA, illustrates its application through various examples, and provides insight into FQAOA's superior performance in constrained combinatorial optimization tasks.\n", - "\n", - "### Constrained Combinatorial Optimization Problems and Cost Hamiltonian\n", - "The constrained combinatorial optimization problem for a polynomial cost function　$C_{\\boldsymbol x}$ covered here can be written in the following form：\n", - "$${\\boldsymbol x}^* = \\arg \\min_{\\boldsymbol x} C_{\\boldsymbol x}\\qquad {\\rm s.t.} \\quad\\sum_{i=1}^{N} x_i = M,$$\n", - "with bit string ${\\boldsymbol x}\\in \\{0,1\\}^N$, where ${\\boldsymbol x}^*$ is the optimal solution.\n", - "This problem can be replaced by the minimum eigenvalue problem in the following steps.\n", - "\n", - "1. map the cost function $C_{\\boldsymbol x}$ to the cost Hamiltonian $\\hat{\\cal H}_C$ by $x_i\\rightarrow \\hat{n}_i$:\n", - "\\begin{eqnarray}\n", - "C_{\\boldsymbol x} &=& \\sum_i \\mu_i x_{i}+\\sum_{i,j} \\sigma_{i,j} x_{i}x_{j}\n", - "&\\quad\\mapsto\\quad&\\hat{\\cal H}_C=\\sum_i \\mu_i \\hat{n}_{i}+\\sum_{i,j} \\sigma_{i,j} \\hat{n}_{i_1}\\hat{n}_{i_2},\n", - "\\end{eqnarray}\n", - "where $\\hat{n}_i = \\hat{c}^\\dagger_i\\hat{c}_i$ is number operator and $\\hat{c}_i^\\dagger (\\hat{c}_i)$ is creation (annihilation) operator of fermion at $i$-th site.\n", - "\n", - "2. formulate eigen value problems for combinatorial optimization problem under the constraint:\n", - "\\begin{eqnarray}\n", - "\\hat{\\cal H}_C|x_1x_2\\cdots x_N\\rangle &=& C_{\\boldsymbol x}|x_1x_2\\cdots x_N\\rangle,\\\\\n", - "\\sum_{i=1}^{N} \\hat{n}_i|x_1x_2\\cdots x_N\\rangle &=& M|x_1x_2\\cdots x_N\\rangle,\n", - "\\end{eqnarray}\n", - "where $|x_1x_2\\cdots x_N\\rangle=(\\hat{c}^\\dagger_1)^{x_1}(\\hat{c}^\\dagger_2)^{x_2}\\cdots (\\hat{c}^\\dagger_N)^{x_N}|{\\rm vac}\\rangle$ is fermionic basis state and $|\\rm vac\\rangle$ is vacuum satisfying $\\hat{c}_i|\\rm vac\\rangle=0$.\n", - "\n", - "3. optimize FQAOA ansatz:\n", - "$$|\\psi_p({\\boldsymbol \\gamma}^*, {\\boldsymbol \\beta}^*)\\rangle \n", - "= \\left[\\prod_{j=1}^pU(\\hat{\\cal H}_M,\\beta_j^*){U}(\\hat{\\cal H}_C,\\gamma_j^*)\\right]\\hat{U}_{\\rm init}|{\\rm vac}\\rangle\n", - "\\qquad {\\rm by}\\quad\n", - "C_p({\\boldsymbol \\gamma}^*, {\\boldsymbol \\beta}^*)=\\min_{{\\boldsymbol \\gamma}, {\\boldsymbol \\beta}}C_p({\\boldsymbol \\gamma},{\\boldsymbol \\beta}),$$\n", - "$$\\qquad{\\rm where \\quad}C_p({\\boldsymbol \\gamma}, {\\boldsymbol \\beta}) = \\langle\\psi_p({\\boldsymbol \\gamma}, {\\boldsymbol \\beta})|\\hat{\\cal H}_C|\\psi_p({\\boldsymbol \\gamma}, {\\boldsymbol \\beta})\\rangle.$$\n", - "The variational parameters $({\\boldsymbol \\gamma}^*, {\\boldsymbol \\beta}^*)$ give the lowest cost value at QAOA level $p$.\n", - "\n", - "\n", - "### One-Dimensional Mixer Hamiltonian\n", - "\n", - "The FQAOA implemented on OpenQAOA employs mixer Hamiltonians on one-dimensional lattices. The main features of this computational model are summarized based on the study [2]:\n", - "\n", - "- Utilises a mixer Hamiltonian on a one-dimensional lattice dedicated to combinatorial optimization problems with equality constraints of the same coefficients.\n", - "\n", - "- Reduced Gate Operations: The new mixer Hamiltonian significantly reduces the number of gate operations in quantum circuits compared to previous studies [1], thus improving computational efficiency.\n", - "\n", - "- Noise suppression: as demonstrated in a 16-qubit trapped-ion quantum computer on Amazon Braket, the proposed mixer Hamiltonian effectively suppresses noise and improves algorithm performance.\n", - "\n", - "As these features enhance the performance and reliability of FQAOA for solving constrained combinatorial optimization problems, we focus on FQAOA with one-dimensional mixer hamiltonians.\n", - "\n", - "The specific mixer Hamiltonian $\\hat{\\cal H}_M$ on cyclic lattice to be implemented in OpenQAOA are as follow:\n", - "\n", - "\\begin{eqnarray}\n", - "\\hat{\\cal H}_M &=& t\\sum_{i=1}^{N-1} (\\hat{c}^\\dagger_i\\hat{c}_{i+1}+\\hat{c}^\\dagger_{i+1}\\hat{c}_i)-t(-1)^{M}(\\hat{c}^\\dagger_N\\hat{c}_{1}+\\hat{c}^\\dagger_{1}\\hat{c}_N).\n", - "\\end{eqnarray}\n", - "These Hamiltonians can be diagonalized as:\n", - "$$\\hat{\\cal H}_M=\\sum_{i=1}^{N}\\varepsilon_i\\hat{\\gamma}_i^\\dagger\\hat{\\gamma}_i \\qquad {\\rm with} \\quad\n", - "\\hat{\\gamma}_i^\\dagger = \\sum_{j=1}^N[\\phi_0]_{i,j}\\hat{c}^\\dagger_j,$$\n", - "where $[\\phi_0]$ is the unitary matrix used for the diagonalization and $\\varepsilon_i$ is eigenvalue.\n", - "The formulation and validation of the model on cyclic lattice are detailed in the study [2].\n", - "\n", - "### Initial State and Mixer for FQAOA\n", - "\n", - "We describe the specific calculation model utilized for our implementation of the FQAOA on cyclic lattice. \n", - "The initial state preparation unitary $\\hat{U}_{\\rm init}$ and the mixer $\\hat{U}_M$ used to implement the FQAOA are shown below.\n", - "\n", - "- initial state preparation unitary $\\hat{U}_{\\rm init}$ on cyclic lattice:\n", - "$$|\\phi_0\\rangle=\\hat{U}_{\\rm init}|{\\rm vac}\\rangle=\\left(\\prod_{i=1}^{M}\\hat{\\gamma}_i^\\dagger\\right)|{\\rm vac}\\rangle,\n", - "\\qquad{\\rm with}\\quad \\hat{U}_{\\rm init}=\\prod_{i=1}^{M}\\left(\\sum_{j=1}^N[\\phi_0]_{i,j}\\hat{c}^\\dagger_j\\right),$$\n", - "where $M$ is the number of fermions and $i$ indexes the eigenvalues $\\varepsilon_i$ in ascending order.\n", - "The implementation of the initial state preparation unitary on quantum circuit are shown in Refs. [1-3].\n", - "\n", - "- mixing unitary $U(\\hat{\\cal H}_M, \\beta)$ on cyclic lattice:\n", - "\\begin{eqnarray}\n", - "U(\\hat{\\cal H}_M, \\beta) &\\sim&\n", - "\\exp\\left[i\\beta t(-1)^M\\left(\\hat{c}^{\\dagger}_{ND}\\hat{c}_{1}+\\hat{c}^{\\dagger}_{1}\\hat{c}_{ND}\\right)\\right]\n", - "\\prod_{i\\ {\\rm even}}\\exp\\left[-i\\beta t\\left(\\hat{c}^{\\dagger}_i\\hat{c}_{i+1}+\\hat{c}^{\\dagger}_{i+1}\\hat{c}_{i}\\right)\\right]\n", - "\\prod_{i\\ {\\rm odd}}\\exp\\left[-i\\beta t\\left(\\hat{c}^{\\dagger}_i\\hat{c}_{i+1}+\\hat{c}^{\\dagger}_{i+1}\\hat{c}_{i}\\right)\\right],\n", - "\\end{eqnarray}\n", - "where the approximation by Trotter decomposition is applied, as certain hopping terms are non-commutative.\n", - "The implementation of the mixed unitary indicated on the right-hand side on quantum circuits is given in Refs. [1, 2, 4, 5]." - ] - }, - { - "cell_type": "markdown", - "id": "345d258f-4b46-4bd3-a709-7726b3e43b3c", - "metadata": {}, - "source": [ - "## Constrained Quadratic Optimization Problem" - ] - }, - { - "cell_type": "markdown", - "id": "ce6be6d4-7355-4ce8-bf68-17edb5f467ec", - "metadata": {}, - "source": [ - "The objective function of the constrined optimization problem is given by \n", - "\n", - "$$\\min_{x} : q {\\boldsymbol x}^{T} {\\boldsymbol \\sigma} {\\boldsymbol x}-{\\boldsymbol\\mu}^{T} {\\boldsymbol x},\\qquad {\\rm s.t.} \\quad\\sum_{i=1}^{N} x_i = M,$$\n", - "\n", - "where:\n", - "- $N$: number of decision variables,\n", - "- ${\\boldsymbol x} \\in\\{0,1\\}^{N}$: vector of binary decision variables,\n", - "- ${\\boldsymbol \\mu} \\in R^{n}$: vector coefficients for the linear term,\n", - "- ${\\boldsymbol \\sigma} \\in R^{n \\times n}$: symmetric positive semidefinite matrix for quadratic term,\n", - "- $q$: quadratic term coeffient,\n", - "- $M$: constraint on the sum of decision variables." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "d3e2b171-0013-4e2e-9801-8a6a58d50370", - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib notebook\n", - "%matplotlib inline\n", - "\n", - "# Import the libraries needed to employ the QAOA and FQAOA quantum algorithm using OpenQAOA\n", - "from openqaoa import FQAOA\n", - "from openqaoa import QAOA\n", - "\n", - "# method to covnert a docplex model to a qubo problem\n", - "from openqaoa.problems import PortfolioOptimization\n", - "from openqaoa.backends import create_device\n", - "from openqaoa.utilities import bitstring_energy\n", - "from openqaoa.algorithms.fqaoa import fqaoa_utils\n", - "\n", - "# Import external libraries to present an manipulate the data\n", - "import pandas as pd\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "id": "8d47957a-251f-4206-8199-2c551713a754", - "metadata": {}, - "source": [ - "# Portfolio Optimizaton\n", - "\n", - "In the following, the [portfolio optimization problem](https://en.wikipedia.org/wiki/Portfolio_optimization) is taken as a constrained quadratic formal optimisation problem.\n", - "In this case, $N$ and $M$ in the equation are the number of the assets and the budget, respectively." - ] - }, - { - "cell_type": "markdown", - "id": "bb6a05c9-82f7-431b-b60f-de61cd71d3cf", - "metadata": {}, - "source": [ - "## Generate the input data\n", - "\n", - "To simplify the problem, it is used a random function to generate the predictions the expected return for 10 assets during 15 days as in [6]. " - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "06460e0b-e03f-46f3-8008-1ef9688f3e57", - "metadata": {}, - "outputs": [], - "source": [ - "# generate the input data for portfolio optimization\n", - "num_assets = 10 # number of assets\n", - "num_days = 15 # number of days\n", - "seed = 1 # seed of random number\n", - "mu, sigma, hist_exp = fqaoa_utils.generate_random_portfolio_data(num_assets, num_days, seed)" - ] - }, - { - "cell_type": "markdown", - "id": "af6a15f0-be1a-4fb4-81a8-6a352b7dcc27", - "metadata": {}, - "source": [ - "Graphical representation of 10 stock behavior and covariance matrix." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "dd4e138c-c112-49e7-862f-d8aa0f6ae69c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Covariance Matrix $\\\\Sigma$ associated to the risk')" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot the stock's time series\n", - "fig, ax = plt.subplots(1, 2, figsize=(14,5))\n", - "colors = plt.cm.tab20(range(20))\n", - "for i in range(num_assets):\n", - " ax[0].plot(range(1, num_days+1), hist_exp[i], color=colors[i])\n", - "ax[0].set_xlabel(\"day\")\n", - "ax[0].set_ylabel(\"Expected Returns [$]\")\n", - "ax[0].legend([f\"Asset {i}\" for i in range(1, num_assets+1)])\n", - "im = ax[1].imshow(sigma, cmap=\"coolwarm\")\n", - "fig.colorbar(im)\n", - "\n", - "# Plot the covariance matrix\n", - "ax[1].set_yticks(range(num_assets))\n", - "ax[1].set_xticks(range(num_assets))\n", - "ax[1].set_xticklabels([f\"Asset {i}\" for i in range(1, num_assets+1)], rotation=45)\n", - "ax[1].set_yticklabels([f\"Asset {i}\" for i in range(1, num_assets+1)], rotation=45)\n", - "ax[1].set_title(r\"Covariance Matrix $\\Sigma$ associated to the risk\")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "d30abc93-34e2-41cd-9d9b-54773fe37a27", - "metadata": {}, - "outputs": [], - "source": [ - "# converts the portfolio optimization problem into a QUBO format.\n", - "budget = 5 # budget constraint value\n", - "problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo" - ] - }, - { - "cell_type": "markdown", - "id": "fe2621d4", - "metadata": {}, - "source": [ - "## Solving the problem using FQAOA" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "6d2328a6-88f2-4a85-964e-d00f036d044a", - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "# Indicate the device, this case is a local simulator\n", - "device = create_device('local', 'qiskit.statevector_simulator')" - ] - }, - { - "cell_type": "markdown", - "id": "f54c48a2", - "metadata": {}, - "source": [ - "The quantum algorithms consider the following properties: the qiskit's statevector_simulator backend with a `p` value equals to 2, with `ramp` initialization." - ] - }, - { - "cell_type": "markdown", - "id": "f7eb209f-387b-4987-b642-e76f61168cf1", - "metadata": {}, - "source": [ - "### Optimization using FQAOA\n", - "\n", - "Here, a fermionic mixer Hamiltonian $\\hat{\\cal H}_M$ on cyclic lattice determines its ground state as the initial state $\\hat{U}_{\\rm init}|\\rm vac\\rangle$ and its mixer $U(\\hat{\\cal H}_M, \\beta)$." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "11087210-d89c-4b4d-a85a-576a1faad80f", - "metadata": {}, - "outputs": [], - "source": [ - "fqaoa = FQAOA(device)\n", - "fqaoa.set_circuit_properties(p=2)\n", - "fqaoa.fermi_compile(problem = problem, n_fermions = budget)\n", - "fqaoa.optimize()\n", - "fqaoa_results = fqaoa.result" - ] - }, - { - "cell_type": "markdown", - "id": "4c4dd7b9-0389-4689-a4fd-52917e6d7b06", - "metadata": {}, - "source": [ - "### Optimization using Conventional QAOA\n", - "\n", - "Here, the conventional X-mixer Hamiltonian $H_M$ determines its ground state as the initial state and its unitary transformation $\\exp(-i\\beta\\hat{\\cal H}_M)$ as the mixer." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "0ee8df0b-e25d-4f9b-8304-1bdff0acb64b", - "metadata": {}, - "outputs": [], - "source": [ - "qaoa = QAOA(device)\n", - "qaoa.set_circuit_properties(p=2)\n", - "qaoa.compile(problem = problem)\n", - "qaoa.optimize()\n", - "qaoa_results = qaoa.result" - ] - }, - { - "cell_type": "markdown", - "id": "5bf46716-6f89-4e00-bbae-cbe8a991055e", - "metadata": {}, - "source": [ - "### Performance Evaluation of FQAOA" - ] - }, - { - "cell_type": "markdown", - "id": "7571203b-664e-40c9-ba7d-209372403a80", - "metadata": {}, - "source": [ - "To evalueate the performance of FQAOA, we show expectation value of costs. \n", - "We define normalized costs by \n", - "$\\Delta C_{\\boldsymbol x}/W$ with $\\Delta C_{\\boldsymbol x} = (C_{\\boldsymbol x}-C_{\\rm min})$ and $W=(C_{\\rm max}-C_{\\rm min})$, where $C_{\\rm max}$ ($C_{\\rm min}$) is maximum (minimum) value of cost under the cosntraint." - ] - }, - { - "cell_type": "markdown", - "id": "7f41514a-77d4-44c8-8cf1-990a2168d153", - "metadata": {}, - "source": [ - "#### maximum-minimum estimations of costs for normalization" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "fe328715-f5ef-4422-aae4-a5e9dd745942", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(min C_x, max C_x) = ( -2.6042725099164272 210.7614169508679 )\n" - ] - } - ], - "source": [ - "x_in_constraint = []\n", - "for i in range(2**num_assets):\n", - " bit = bin(i)[2:].zfill(num_assets)\n", - " cost = bitstring_energy(qaoa.cost_hamil, bit[::-1])\n", - " if bit.count('1') == budget:\n", - " x_in_constraint.append(cost)\n", - "max_x, min_x = max(x_in_constraint), min(x_in_constraint)\n", - "print('(min C_x, max C_x) = ', '(', min_x, max_x,')')" - ] - }, - { - "cell_type": "markdown", - "id": "d89b3c15-bea9-40c7-abe3-d0ba73897597", - "metadata": {}, - "source": [ - "#### cost history" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "9b2c0b91-4de0-4362-9470-1d7a354e5418", - "metadata": {}, - "outputs": [], - "source": [ - "label_list = ['QAOA', 'FQAOA']\n", - "opt_results_list, cost_list = [], []\n", - "exp_cost_dict = {}\n", - "for opt_result in [qaoa_results, fqaoa_results]:\n", - " opt_results_list.append(opt_result)\n", - " cost_list.append(opt_result.optimized['cost'])" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "5125af92-c141-4aae-813c-e2f27956d1c2", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize=(10, 8))\n", - "for i, opt_results in enumerate(opt_results_list):\n", - " opt_results.plot_cost(ax=ax, color=f'C{i}', label=label_list[i])\n", - "ax.grid(True)\n", - "ylim_scaled = 8\n", - "ax.set_ylabel(r'normalized cost, $\\langle \\Delta C_{\\boldsymbol{x}}/W \\rangle$')\n", - "ax.set_ylim(min_x, min_x + ylim_scaled * (max_x - min_x))\n", - "ax.set_yticks([min_x + i * (max_x - min_x) for i in range(ylim_scaled + 1)],\n", - " labels=range(ylim_scaled + 1))\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "9c6dda49-9fb0-4235-9a7d-8e6ba14ecebf", - "metadata": {}, - "source": [ - "### Performance Evaluation of FQAOA" - ] - }, - { - "cell_type": "markdown", - "id": "11c7b1c7-2820-463a-9dd0-cc5b2ec533f3", - "metadata": {}, - "source": [ - "#### expection values of the cost" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "e620d83e-0a6c-433a-af44-1b7a04f0d491", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "expectation values of the cost\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
method$\\langle C_{\\boldsymbol x} \\rangle$$\\langle \\Delta C_{\\boldsymbol x}\\rangle /W$
0QAOA1294.8386166.080841
1FQAOA27.0286620.138883
\n", - "
" - ], - "text/plain": [ - " method $\\langle C_{\\boldsymbol x} \\rangle$ \\\n", - "0 QAOA 1294.838616 \n", - "1 FQAOA 27.028662 \n", - "\n", - " $\\langle \\Delta C_{\\boldsymbol x}\\rangle /W$ \n", - "0 6.080841 \n", - "1 0.138883 " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "exp_cost_dict['method'] = label_list\n", - "exp_cost_dict[r'$\\langle C_{\\boldsymbol x} \\rangle$'] = cost_list\n", - "exp_cost_dict[r'$\\langle \\Delta C_{\\boldsymbol x}\\rangle /W$'] = (np.array(cost_list)-min_x)/(max_x-min_x)\n", - "df = pd.DataFrame(exp_cost_dict)\n", - "print('expectation values of the cost')\n", - "display(df)" - ] - }, - { - "cell_type": "markdown", - "id": "5bb1d29c-9af8-4e6b-bb27-0fca690a7b65", - "metadata": {}, - "source": [ - "#### best 5 states" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "6373b123-b0d2-44db-a4d6-5d2ca44185d8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Comparison of methods for calculating the probability of finding the optimal solutions\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
solutions bitstrings, $\\boldsymbol{x}$cost, $C_{\\boldsymbol x}$normalized cost, $\\Delta C_{\\boldsymbol x}/W$Probability (QAOA)Probability (FQAOA)
01101100001-2.6042730.0000000.0000340.009313
11101000101-2.4729650.0006150.0000920.018148
21101001001-2.2997220.0014270.0000010.012510
31100100101-2.1608150.0020780.0000060.004845
41100100011-1.8206970.0036720.0000690.012701
\n", - "
" - ], - "text/plain": [ - " solutions bitstrings, $\\boldsymbol{x}$ cost, $C_{\\boldsymbol x}$ \\\n", - "0 1101100001 -2.604273 \n", - "1 1101000101 -2.472965 \n", - "2 1101001001 -2.299722 \n", - "3 1100100101 -2.160815 \n", - "4 1100100011 -1.820697 \n", - "\n", - " normalized cost, $\\Delta C_{\\boldsymbol x}/W$ Probability (QAOA) \\\n", - "0 0.000000 0.000034 \n", - "1 0.000615 0.000092 \n", - "2 0.001427 0.000001 \n", - "3 0.002078 0.000006 \n", - "4 0.003672 0.000069 \n", - "\n", - " Probability (FQAOA) \n", - "0 0.009313 \n", - "1 0.018148 \n", - "2 0.012510 \n", - "3 0.004845 \n", - "4 0.012701 " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Print the best 5 solutions\n", - "lowest_dict = opt_results_list[0].lowest_cost_bitstrings(5)\n", - "list1 = lowest_dict['bitstrings_energies']\n", - "normalized_cost = [(x - min_x) / (max_x - min_x) for x in list1]\n", - "qaoa_dict = {\n", - " r'solutions bitstrings, $\\boldsymbol{x}$': lowest_dict['solutions_bitstrings'],\n", - " r'cost, $C_{\\boldsymbol x}$': list1,\n", - " r'normalized cost, $\\Delta C_{\\boldsymbol x}/W$': normalized_cost,\n", - " f'Probability ({label_list[0]})': lowest_dict.pop('probabilities'),\n", - " f'Probability ({label_list[1]})': opt_results_list[1].lowest_cost_bitstrings(5)['probabilities']\n", - "}\n", - "df = pd.DataFrame(qaoa_dict)\n", - "print('Comparison of methods for calculating the probability of finding the optimal solutions')\n", - "display(df)" - ] - }, - { - "cell_type": "markdown", - "id": "7ce08877-3234-485a-8abf-1b72ef0f98fc", - "metadata": {}, - "source": [ - "#### probability distribution of costs." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "de27622f-bfcb-4573-96d7-fbba08d1d159", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plot energy distribution\n", - "xvalues, yvalues = [], []\n", - "for opt_results in opt_results_list:\n", - " measurement_outcomes = opt_results.optimized['measurement_outcomes']\n", - " costprob = []\n", - " for i, amplitude in enumerate(measurement_outcomes):\n", - " bit = bin(i)[2:].zfill(num_assets)\n", - " probability = abs(amplitude)**2\n", - " costprob.append([bitstring_energy(qaoa.cost_hamil, bit[::-1]), probability, bit])\n", - " # Extracting the second values from the data points for the histogram\n", - " xvalues.append([(point[0]-min_x)/(max_x-min_x) for point in costprob])\n", - " yvalues.append([point[1] for point in costprob])\n", - "xmax, bins = 1.0, 20\n", - "figsize=(10, 8)\n", - "fig, ax = plt.subplots(figsize=figsize)\n", - "ax.set_xlim(0, xmax)\n", - "ax.set_ylim(0, 0.5)\n", - "ax.hist(xvalues, bins = np.linspace(0, xmax, bins+1), weights=yvalues, edgecolor='black', label = label_list)\n", - "ax.set_xlabel(r'normalized cost, $\\Delta C_{\\boldsymbol{x}}/W$')\n", - "ax.set_ylabel('Probability')\n", - "ax.grid(True)\n", - "ax.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "8106c098-1fe7-43ad-b276-8aeeb57f0e7d", - "metadata": {}, - "source": [ - "# References\n", - "\n", - "[1] T. Yoshioka, K. Sasada, Y. Nakano, and K. Fujii, [Phys. Rev. Research 5, 023071 (2023).](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071), [arXiv: 2301.10756 [quant-ph]](https://arxiv.org/pdf/2301.10756). \\\n", - "[2] T. Yoshioka, K. Sasada, Y. Nakano, and K. Fujii, [2023 IEEE International Conference on Quantum Computing and Engineering (QCE) 1, 300-306 (2023).](https://ieeexplore.ieee.org/document/10313662), [arXiv: 2312.04710 [quant-phi]](https://arxiv.org/pdf/2312.04710). \\\n", - "[3] Z. Jiang, J. S. Kevin, K. Kechedzhi, V. N. Smelyanskiy, and S. Boixo, [Phys. Rev. Appl. 9, 044036 (2018).](https://journals.aps.org/prapplied/abstract/10.1103/PhysRevApplied.9.044036) \\\n", - "[4] S. Hadfield, Z. Wang, B. O’Gorman, E. G. Rieffel, D. Venturelli, and R. Biswas, [algorithms 12, 34 (2019).](https://www.mdpi.com/1999-4893/12/2/34) \\\n", - "[5] Z. Wang, N. C. Rubin, J. M. Dominy, and E. G. Rioeffel, [Phys. Rev. A 101, 012320 (2020).](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.101.012320) \\\n", - "[6] [openqaoa/examples/community_tutorials/03_portfolio_optimization.ipynb](https://github.com/entropicalabs/openqaoa/blob/main/examples/community_tutorials/03_portfolio_optimization.ipynb)" - ] - } - ], - "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": 5 -} diff --git a/examples/17_FQAOA_advanced_parameterization.ipynb b/examples/17_FQAOA_advanced_parameterization.ipynb index 10dcfcfb2..73429909a 100644 --- a/examples/17_FQAOA_advanced_parameterization.ipynb +++ b/examples/17_FQAOA_advanced_parameterization.ipynb @@ -7,7 +7,7 @@ "source": [ "# 17 - FQAOA circuit with advanced circuit parameterizations\n", "\n", - "This notebook describes how to apply the annealing and Fourier parameter classes included in OpenQAOA to FAOA frame work." + "This notebook describes how to apply the annealing and Fourier parameter classes included in OpenQAOA to FQAOA frame work." ] }, { @@ -27,7 +27,7 @@ "# method to covnert a docplex model to a qubo problem\n", "from openqaoa.problems import PortfolioOptimization\n", "from openqaoa.backends import create_device\n", - "from openqaoa.algorithms.fqaoa import fqaoa_utils\n", + "from openqaoa.utilities import bitstring_energy\n", "\n", "# Import external libraries to present an manipulate the data\n", "import numpy as np\n", @@ -42,9 +42,7 @@ "id": "bb6a05c9-82f7-431b-b60f-de61cd71d3cf", "metadata": {}, "source": [ - "### Create a Problem Instance\n", - "\n", - "To simplify the problem, it is used a random function to generate the predictions the expected return for 10 assets during 15 days as in [6]. " + "Start by creating an instance of the portfolio optimisation problem, using the `random_instance` method of `the PortfolioOptimisation` class." ] }, { @@ -54,13 +52,10 @@ "metadata": {}, "outputs": [], "source": [ - "# generate the input data for portfolio optimization\n", + "# create a problem instance for portfolio optimization\n", "num_assets = 4 # number of assets\n", "budget = 2 # budget constraint value\n", - "num_days = 15 # number of days\n", - "seed = 1 # seed of random number\n", - "mu, sigma, hist_exp = fqaoa_utils.generate_random_portfolio_data(num_assets, num_days, seed)\n", - "problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo" + "problem = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget, penalty=None).qubo" ] }, { @@ -70,7 +65,7 @@ "source": [ "## Quantum Annealing with FQAOA\n", "\n", - "The framework of Fermionic QAOA (FQAOA) covers the Quantum Annealing (QA) framework [1]. In this note, we demonstrate that QA with FQAOA works for constrained combinatorial optimisation problems in practice and compare its performance with QA with conventional QAOA [2]." + "The framework of Fermionic QAOA (FQAOA) covers the Quantum Annealing (QA) framework [[1]](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071). In this note, we demonstrate that QA with FQAOA works for constrained combinatorial optimisation problems in practice and compare its performance with QA with conventional QAOA [[2]](https://arxiv.org/pdf/quant-ph/0001106)." ] }, { @@ -79,14 +74,14 @@ "metadata": {}, "source": [ "### FQAOA Ansatz for QA\n", - "FQAOA supports a discretised form of quantum annealing.\n", + "FQAOA supports a discretized form of quantum annealing.\n", "Quantum annealing starts with a mixer Hamiltonian ground state and gradually evolves to a cost Hamiltonian ground state.\n", "If the transformation can be performed slowly to infinity, it is guaranteed to reach the exact ground state of the cost Hamiltonian.\n", "In practice, the transformation is performed over a finite time and we want to prepare the ground state with some high probability.\n", "\n", "The approximated ground state obtained by QA are as follows:\n", "$$|\\psi(T)\\rangle = {\\cal T}\\exp\\left\\{ -i\\int_0^T \\left[\\left(1-\\frac{t}{T}\\right)\\hat{\\cal H}_M+\\frac{t}{T}\\hat{\\cal H}_C\\right] dt\\right\\}\\hat{U}_{\\rm init}|{\\rm vac}\\rangle,$$\n", - "where the cost $\\hat{\\cal H}_C$ and mixer $\\hat{\\cal H}_M$ Hamiltonians, and initial state preparation unitary $\\hat{U}_{\\rm init}$ are given in the notebook `16-FQAOA_examples`. $T$ is annealing time and $\\cal T$ is time ordering product for $t$.\n", + "where the cost $\\hat{\\cal H}_C$ and mixer $\\hat{\\cal H}_M$ Hamiltonians, and initial state preparation unitary $\\hat{U}_{\\rm init}$ are given in the notebook [`16 - Fermionic QAOA (FQAOA)`](https://github.com/tech-sketch/openqaoa/blob/yoshioka1128/dev_clean_fqaoa/examples/16_FQAOA_examples.ipynb). $T$ is annealing time and $\\cal T$ is time ordering product for $t$.\n", "\n", "The $|\\psi(T)\\rangle$ is approximated in the following form for calculation in quantum circuits [1, 2]:\n", "$$|\\psi(T)\\rangle\\sim|\\psi_p({\\boldsymbol \\gamma}^{(0)}, {\\boldsymbol \\beta}^{(0)})\\rangle \n", @@ -96,7 +91,7 @@ " \\gamma_j^{(0)} &=& \\frac{2j-1}{2p}\\Delta t, \\\\\n", " \\beta_j^{(0)} &=& \\left(1-\\frac{2j-1}{2p}\\right)\\Delta t,\n", "\\end{eqnarray}\n", - "where $\\Delta t$ is the unit of descretized annealing time, as $T=p\\Delta t$.\n", + "where $\\Delta t$ is the unit of discretized annealing time, as $T=p\\Delta t$.\n", "\n", "In the FQAOA ansatz, the following constraints can be imposed on any integer $M$ smaller than the number of qubits $N$ as:\n", "$$\\sum_{i=1}^{N} \\hat{n}_i|\\psi_p({\\boldsymbol \\gamma^{(0)}}, {\\boldsymbol \\beta}^{(0)})\\rangle = M|\\psi_p({\\boldsymbol \\gamma^{(0)}}, {\\boldsymbol \\beta}^{(0)})\\rangle,$$\n", @@ -110,7 +105,7 @@ "id": "f7eb209f-387b-4987-b642-e76f61168cf1", "metadata": {}, "source": [ - "### QA using FQAOA Ansatz" + "### Running QA using FQAOA Ansatz" ] }, { @@ -125,13 +120,13 @@ "# QA using FQAOA\n", "fqaoa_cost_list = []\n", "fqaoa_ip_values = range(1, 11)\n", - "fqaoa_dt = 0.1\n", + "fqaoa_dt = 0.2\n", "\n", "for ip in fqaoa_ip_values:\n", " fqaoa = FQAOA(device)\n", " fqaoa.set_circuit_properties(p=ip, param_type='annealing', init_type='ramp', annealing_time=fqaoa_dt*ip)\n", " fqaoa.set_classical_optimizer(maxiter=0)\n", - " fqaoa.fermi_compile(problem = problem, n_fermions = budget)\n", + " fqaoa.compile(problem = problem, n_fermions = budget)\n", " fqaoa.optimize()\n", " fqaoa_cost_list.append(fqaoa.result.optimized['cost'])" ] @@ -141,7 +136,7 @@ "id": "4c4dd7b9-0389-4689-a4fd-52917e6d7b06", "metadata": {}, "source": [ - "### QA using Conventional QAOA Ansatz" + "### Running QA using QAOA Ansatz" ] }, { @@ -154,7 +149,7 @@ "# QA using QAOA\n", "qaoa_cost_list = []\n", "qaoa_ip_values = range(1, 101)\n", - "qaoa_dt = 0.01\n", + "qaoa_dt = 0.02\n", "\n", "for ip in qaoa_ip_values:\n", " qaoa = QAOA(device)\n", @@ -170,18 +165,47 @@ "id": "ef9f898f-32fa-471d-8fb3-3d97a7b1b0d7", "metadata": {}, "source": [ - "## Performance Evaluation of QA with FQAOA" + "## Performance Evaluation of QA with FQAOA\n", + "\n", + "To evaluate the performance of FQAOA, we show expectation value of costs. \n", + "We define normalized costs by \n", + "$\\Delta C_{\\boldsymbol x}/W$ with $\\Delta C_{\\boldsymbol x} = (C_{\\boldsymbol x}-C_{\\rm min})$ and $W=(C_{\\rm max}-C_{\\rm min})$, where $C_{\\rm max}$ ($C_{\\rm min}$) is maximum (minimum) value of cost under the constraint." ] }, { "cell_type": "code", "execution_count": 5, + "id": "4107fd95-d4a1-44ad-abf4-70bc50b7b5e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(min C_x, max C_x) = ( -1.7800188086068625 0.7095615310972656 )\n" + ] + } + ], + "source": [ + "x_in_constraint = []\n", + "for i in range(2**num_assets):\n", + " bit = bin(i)[2:].zfill(num_assets)\n", + " cost = bitstring_energy(qaoa.cost_hamil, bit[::-1])\n", + " if bit.count('1') == budget:\n", + " x_in_constraint.append(cost)\n", + "max_x, min_x = max(x_in_constraint), min(x_in_constraint)\n", + "print('(min C_x, max C_x) = ', '(', min_x, max_x,')')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, "id": "51385cb6-0205-48ce-994f-5f4bbd6ce2af", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHLCAYAAAAgBSewAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAACKNklEQVR4nO3deVzUxf8H8NfuslzKISCXIiLmWV55hCVqgqhl2eXxS1MzK9PSzEw7VKzUzKs8ssw7ryyPvuVNAh6oeeWRF4o3oKDc17I7vz+WXXbZBRZkWVhez8djg53PfD47swvybuY985EIIQSIiIiIahCppRtAREREVNkYABEREVGNwwCIiIiIahwGQERERFTjMAAiIiKiGocBEBEREdU4DICIiIioxmEARERERDUOAyAiIiKqcRgAEVGZSCQSTJs2Tft81apVkEgkuH79usXaRDXDtGnTIJFI9MoaNmyIYcOGWaZBJoiMjIREIkFkZKSlm0JFMACiYp0/fx6DBw9GvXr1YGdnB19fXwwePBj//fefpZum57///sO0adOq/B/gjh07QiKR4IcffrB0U6zO6dOnMXjwYPj5+cHOzg5ubm4ICQnBypUroVQqK/z17t69i2nTpuH06dMVfm1z2LFjByQSCXx9faFSqSzdnGpv2LBhkEgkpT6qcmBGgI2lG0BV05YtWzBo0CC4ublhxIgRCAgIwPXr17F8+XL89ttv2LRpE1588UVLNxOAOgAKDw9Ht27d0LBhQ0s3x6grV67gn3/+QcOGDbFu3TqMGjXK0k2qMEOGDMHAgQNhZ2dnkdf/+eef8e6778LLywtDhgzBY489hvT0dERERGDEiBGIj4/Hp59+WqGveffuXYSHh6Nhw4Zo06ZNhV7bHNatW4eGDRvi+vXr+PvvvxESEmLpJlWYS5cuQSqt3P+Xf+edd/Tew7i4OEyZMgVvv/02unTpoi0PDAxEp06dkJ2dDVtb20ptI5WOARAZuHr1KoYMGYJGjRohOjoadevW1R4bO3YsunTpgsGDB+PMmTMICAiwYEurj19++QWenp6YO3cuXn31VVy/fr3KBmtlJZPJIJPJLPLaR44cwbvvvougoCDs2LEDTk5O2mPjxo3D8ePHce7cOYu0rarIzMzE9u3bMXPmTKxcuRLr1q2zqgDIEoF3UFAQgoKCtM+PHz+OKVOmICgoCIMHDzaob29vX5nNI1MJoiLeeecdAUBER0cbPR4VFSUAiFGjRmnLhg4dKvz9/Q3qTp06VRT9MVuxYoXo3r27qFu3rrC1tRXNmzcXS5YsMTjX399fPPfcc+LAgQOiQ4cOws7OTgQEBIjVq1dr66xcuVIAMHjs379fCCEEADF16lSj1x46dKjBdQ4cOCDef/994eHhIVxcXMTbb78tcnNzxcOHD8WQIUOEq6urcHV1FR9//LFQqVQlvIv6GjduLN577z2Rm5srXF1dxddff13se3XlyhUxdOhQ4eLiIpydncWwYcNEZmamXl0AYvTo0WLr1q2iZcuWwtbWVrRo0ULs3LnT4Lq3b98Ww4cPF56entp6y5cv16uTm5srvvjiC9GuXTvh7OwsHB0dxTPPPCP+/vtvg+sVfU81711cXJy2zJTPTuPff/8VwcHBwt7eXtSrV098+eWXYsWKFQbXNKZXr17CxsZG3Lhxo8R6GhkZGWL8+PGifv36wtbWVjRp0kR8++23Bp/lnj17xNNPPy1cXFxErVq1RJMmTcTkyZOFEELs37/f6M/cypUrjb7m5s2bBQARGRlpcGzp0qUCgDh79qwQQoj4+HgxbNgwUa9ePWFrayu8vb3FCy+8UOr7UJK1a9cKqVQq4uPjxTfffCOcnZ1Fdna2QT1Tf6bK8nOqef127doJe3t7UadOHTFgwABx8+ZNvTrR0dHi1VdfFX5+fsLW1lbUr19fjBs3TmRlZRl9bV3F/S4fPHhQfPjhh8LDw0M4OjqKfv36iXv37umdq1QqxdSpU4WPj49wcHAQ3bp1E+fPnze4Zmn++eefYn8GND8vmn+ThBCia9euomXLltqffQcHBxEYGCg2b94shBAiMjJSdOzYUdjb24smTZqIvXv3GlzXlN9rKhkDIDLg6+srGjZsWGKdhg0bivr162uflyUA6tChgxg2bJiYP3++WLhwoejZs6cAIBYtWqRXz9/fXzRt2lR4eXmJTz/9VCxatEi0a9dOSCQSce7cOSGEEFevXhUffPCBACA+/fRTsXbtWrF27VqRkJAghCh7ANSmTRvRq1cvsXjxYjFkyBABQEycOFE888wz4v/+7//EkiVLxPPPPy8AGP1jbsyRI0e0wZUQQrz55puiRYsWxb5Xbdu2FS+//LJYsmSJeOutt7Rt0AVAtG7dWvj4+Igvv/xSLFiwQDRq1Eg4OjqKpKQkbb2EhARRv3594efnJ6ZPny5++OEH8cILLwgAYv78+dp69+/fFz4+PmL8+PHihx9+ELNnzxZNmzYVcrlcnDp1yuC1TQmASvvshFD/I+7m5ibc3d1FeHi4mDNnjmjWrJlo3bp1qQFQZmamkMvl4tlnny3h3S+kUqnEs88+KyQSiXjrrbfEokWLRN++fQUAMW7cOG29c+fOCVtbW9G+fXvx3XffiaVLl4oJEyaI4OBg7Xs6ffp0AUC8/fbb2p+5q1evGn3drKwsUbt2bfHee+8ZHOvevbto2bKl9nnnzp2Fi4uL+Pzzz8XPP/8sZsyYIbp37y6ioqJM6qMxvXr1Ej169BBCCHHjxg0hkUjEr7/+alDP1J+psvycfvXVV0IikYgBAwaIJUuWiPDwcOHh4SEaNmwoHj58qK33/vvviz59+ogZM2aIH3/8UYwYMULIZDLx6quv6l2vLAFQ27ZtxbPPPisWLlwoPvroIyGTyUT//v31zp04caIAIPr27SsWLVokRo4cKerXry88PDzMHgD5+voKPz8/8fHHH4uFCxeKFi1aCJlMJjZu3Ci8vb3FtGnTxIIFC0S9evWEi4uLSEtL055v6u81lYwBEOlJSUkRAMSLL75YYj3NL5vml7IsAVDR/6sTQoiwsDDRqFEjvTJ/f3+Dkah79+4JOzs78dFHH2nLNP+HrfsPjEZZA6CwsDC90YCgoCAhkUjEu+++qy3Lz88X9evXF127djW4rjFjxowRfn5+2uvu2bNHADAILDTv1ZtvvqlX/tJLLwl3d3eDftna2orY2Fht2b///isAiIULF2rLRowYIXx8fPT+gAkhxMCBA4WLi4v2s8jPzxe5ubl6dR4+fCi8vLwM2mNqAGTKZ/f+++8LiUSi914kJycLNze3UgMgTX/Hjh1bbB1d27ZtEwDEV199pVf+6quvColEon0v58+fLwCI+/fvF3utkv7gGTNo0CDh6ekp8vPztWXx8fFCKpWK6dOnCyHU7zcA8e2335p0TVMkJiYKGxsbsWzZMm1Z586djf5+m/ozZerP6fXr14VMJjMY7Tx79qywsbHRKzf2b8LMmTOFRCLRG90rSwAUEhKi97v84YcfCplMJlJSUoQQ6iDCxsZG9OvXT+9606ZNEwDMHgABEOvXr9eWXbx4UQAQUqlUHDlyRFu+e/dug2ub+ntNJeMqMNKTnp4OAHq5FMZojmvql4WDg4P2+9TUVCQlJaFr1664du0aUlNT9eq2aNFCL6mwbt26aNq0Ka5du1bm1zXFiBEj9JbZdurUCUIIjBgxQlsmk8nQvn17k9qQn5+PTZs2YcCAAdrrPvvss/D09MS6deuMnvPuu+/qPe/SpQuSk5ORlpamVx4SEoLAwEDt81atWsHZ2VnbLiEEfv/9d/Tt2xdCCCQlJWkfYWFhSE1NxcmTJ7V90iRpqlQqPHjwAPn5+Wjfvr22TlmZ8tnt2rULQUFBeonEbm5ueP3110u9vub9KO1nVWPHjh2QyWT44IMP9Mo/+ugjCCGwc+dOAICrqysAYPv27RW2YmrAgAG4d++e3lLo3377DSqVCgMGDACg/r2wtbVFZGQkHj58WCGvu3HjRkilUrzyyivaskGDBmHnzp1GX6O0nyldpf2cbtmyBSqVCv3799f72fP29sZjjz2G/fv3a8/V/TchMzMTSUlJ6Ny5M4QQOHXqVLn6/vbbb+v9Lnfp0gVKpRI3btwAAERERCA/Px/vvfee3nnvv/9+uV6vrGrXro2BAwdqnzdt2hSurq5o3rw5OnXqpC3XfF+e32sqGQMg0mNqYJOeng6JRAIPD48yv8ahQ4cQEhKCWrVqwdXVFXXr1tWu0ikaADVo0MDg/Dp16lTYH4iiir6ei4sLAMDPz8+g3JQ27NmzB/fv30fHjh0RGxuL2NhYxMXFoXv37tiwYYPRP7BF21CnTh0AMHi90t6b+/fvIyUlBT/99BPq1q2r9xg+fDgA4N69e9pzV69ejVatWsHe3h7u7u6oW7cu/vrrL4PPxFSmfHY3btxA48aNDeoZKyvK2dkZgOlB+I0bN+Dr62sQMDVv3lx7HFAHK08//TTeeusteHl5YeDAgfj1118fKRjq1asXXFxcsGnTJm3Zpk2b0KZNGzRp0gSAOpn3m2++wc6dO+Hl5YXg4GDMnj0bCQkJ5X7dX375BR07dkRycrL2569t27bIy8vD5s2bDeqX5fettJ/TK1euQAiBxx57zODn78KFC3o/ezdv3sSwYcPg5uaG2rVro27duujatSsAw38TTFVa+zSfd9GfNTc3N21dc6pfv77BnkYuLi5G/60BUO7fayoeV4GRHhcXF/j6+uLMmTMl1jtz5gzq16+vHTUo+ousUXQPlqtXr6JHjx5o1qwZ5s2bBz8/P9ja2mLHjh2YP3++wR+Z4lYXCSFM7ZJJ7Srt9YyVm9IGzShP//79jR6PiopC9+7dTWpD0dcrrZ7mvRw8eDCGDh1qtG6rVq0AqP9QDhs2DP369cPHH38MT09PyGQyzJw5E1evXjV6bmnM9dlpNG7cGDY2Njh79myFXE/DwcEB0dHR2L9/P/766y/s2rULmzZtwrPPPos9e/aUa8WbnZ0d+vXrh61bt2LJkiVITEzEoUOHMGPGDL1648aNQ9++fbFt2zbs3r0bX3zxBWbOnIm///4bbdu2LdNrarZeAIDHHnvM4Pi6devw9ttv65WV5TMz5edPIpFg586dRuvWrl0bgPp3MTQ0FA8ePMAnn3yCZs2aoVatWrhz5w6GDRtW7sDT3D9/j6os/9YA5fu9ppIxACIDffv2xY8//oiDBw/imWeeMTh+4MABXL9+HePHj9eW1alTBykpKQZ1Nf+XpfG///0Pubm5+OOPP/T+D013OLysigu+imtXXl4e4uPjy/16ptIsPx4wYABeffVVg+MffPAB1q1bZxAAVZS6devCyckJSqWy1GXPv/32Gxo1aoQtW7bovZ9Tp041S9s0/P39ERsba1BurKwoR0dHPPvss/j7779x69Ytg/9zNvZa+/btQ3p6ut4o0MWLF7XHNaRSKXr06IEePXpg3rx5mDFjBj777DPs378fISEhJf7MFWfAgAFYvXo1IiIicOHCBQghtNNfugIDA/HRRx/ho48+wpUrV9CmTRvMnTsXv/zyS5leb926dZDL5Vi7dq3BH9WDBw/i+++/x82bN42O+lSEwMBACCEQEBCgHeUy5uzZs7h8+TJWr16NN954Q1u+d+9es7RLQ/N5x8bG6m3nkZycbLYR5opQlt9rKhmnwMjAhAkT4OjoiHfeeQfJycl6xx48eIB3330Xzs7OGDNmjLY8MDAQqampeiNH8fHx2Lp1q975mn+Idf8vLDU1FStXrix3e2vVqgUARgOwwMBAREdH65X99NNPZtkduKitW7ciMzMTo0ePxquvvmrweP755/H7778jNzfXLK8vk8nwyiuv4Pfffze6F879+/f16gL6n8vRo0cRExNjlrZphIWFISYmRm9H5QcPHhSbH1XU1KlTIYTAkCFDkJGRYXD8xIkTWL16NQCgT58+UCqVWLRokV6d+fPnQyKRoHfv3trXL0qTo6T5rEr6mStOSEgI3NzcsGnTJmzatAkdO3bU+8OblZWFnJwcvXMCAwPh5OSk9zMSHx+PixcvQqFQlPh669atQ5cuXbQBuO7j448/BgBs2LDB5PaX1csvvwyZTIbw8HCDURchhPbfFmM/e0IIfPfdd2ZrGwD06NEDNjY2BjuzF/35qGrK8ntNJeMIEBlo3Lgx1qxZg0GDBuGJJ54w2An64cOH2Lhxo94/3gMHDsQnn3yCl156CR988AGysrLwww8/oEmTJnoJeT179oStrS369u2Ld955BxkZGVi2bBk8PT3LPSrTpk0byGQyfPPNN0hNTYWdnZ020fitt97Cu+++i1deeQWhoaH4999/sXv37nLlLpXVunXr4O7ujs6dOxs9/sILL2DZsmX466+/8PLLL5ulDbNmzcL+/fvRqVMnjBw5Ei1atMCDBw9w8uRJ7Nu3T/vH/vnnn8eWLVvw0ksv4bnnnkNcXByWLl2KFi1aGA0sKsrEiRPxyy+/IDQ0FO+//z5q1aqFn3/+GQ0aNMCDBw9KHWnp3LkzFi9ejPfeew/NmjXT2wk6MjISf/zxB7766isA6pHN7t2747PPPsP169fRunVr7NmzB9u3b8e4ceO0yb/Tp09HdHQ0nnvuOfj7++PevXtYsmQJ6tevrx0RDQwMhKurK5YuXQonJyfUqlULnTp1KnFjULlcjpdffhkbN25EZmYm5syZo3f88uXL6NGjB/r3748WLVrAxsYGW7duRWJiol6y7OTJk7F69WrExcUVu5nm0aNHERsbq/c/Kbrq1auHdu3aYd26dfjkk09KfI/LKzAwEF999RUmT56M69evo1+/fnByckJcXBy2bt2Kt99+GxMmTECzZs0QGBiICRMm4M6dO3B2dsbvv/9u9lEYLy8vjB07FnPnzsULL7yAXr164d9//8XOnTvh4eFRrlG+ymLq7zWVjAEQGfXKK6/g5MmTmDlzJn7++Wfcu3cPKpUK9vb2OHHiBFq0aKFX393dHVu3bsX48eMxceJEBAQEYObMmbhy5YpeANS0aVP89ttv+PzzzzFhwgR4e3tj1KhRqFu3Lt58881ytdXb2xtLly7FzJkzMWLECCiVSuzfvx+enp4YOXIk4uLisHz5cuzatQtdunTB3r170aNHj0d6f0pz79497Nu3D4MGDSp2Tr9Hjx5wdHTEL7/8YrYAyMvLC8eOHcP06dOxZcsWLFmyBO7u7mjZsiW++eYbbb1hw4YhISEBP/74I3bv3o0WLVrgl19+webNm816E0c/Pz/s378fH3zwAWbMmIG6deti9OjRqFWrFj744AOTdtB955130KFDB8ydOxdr1qzB/fv3Ubt2bbRr1w4rV67U7swrlUrxxx9/YMqUKdi0aRNWrlyJhg0b4ttvv8VHH32kvd4LL7yA69evY8WKFUhKSoKHhwe6du2K8PBwbUKqXC7H6tWrMXnyZLz77rvIz8/HypUrS90ZfcCAAfj5558hkUgM8sL8/PwwaNAgREREYO3atbCxsUGzZs3w66+/6q3iMoVmBK1v377F1unbty+mTZuGM2fOmC1nZNKkSWjSpAnmz5+P8PBwAOp+9uzZEy+88AIA9Xv5v//9Dx988AFmzpwJe3t7vPTSSxgzZgxat25tlnZpfPPNN3B0dMSyZcuwb98+BAUFYc+ePXjmmWeq9O7Npv5eU8kkoqpkhFGVt2bNGgwbNgyDBw/GmjVrLN0csmLjxo3Djz/+iIyMDIvdZoNqppSUFNSpUwdfffUVPvvsM0s3h8yII0BksjfeeAPx8fGYNGkS6tevb7CChag8srOz9faBSU5Oxtq1a/HMM88w+CGzKvqzBwALFiwAAHTr1q3yG0SViiNARGRRbdq0Qbdu3dC8eXMkJiZi+fLluHv3LiIiIhAcHGzp5pEVW7VqFVatWoU+ffqgdu3aOHjwIDZs2ICePXti9+7dlm4emRlHgIjIovr06YPffvsNP/30EyQSCdq1a4fly5cz+CGza9WqFWxsbDB79mykpaVpE6M1ifNk3TgCRERERDUO9wEiIiKiGocBEBEREdU4zAEyQqVS4e7du3BycqrSm2ERERFRISEE0tPT4evrC6m05DEeBkBG3L17t9T7ChEREVHVdOvWLdSvX7/EOgyAjNDcKPHWrVtwdnYu93UUCgX27NmDnj17Qi6XV1TzqhT20Tqwj9aBfbQO1t5Hc/YvLS0Nfn5+ejc8Lg4DICM0017Ozs6PHAA5OjrC2dnZKn+IAfbRWrCP1oF9tA7W3sfK6J8p6StMgiYiIqIahwEQERER1TgMgIiIiKjGYQ4QERFRGSmVSigUCrNcW6FQwMbGBjk5OVAqlWZ5DUt6lP7J5fIKu0kyAyAiIiITCSGQkJCAlJQUs76Gt7c3bt26ZZV70T1q/1xdXeHt7f3I7w0DICIiIhNpgh9PT084OjqaJUBRqVTIyMhA7dq1S93Mrzoqb/+EEMjKysK9e/cAAD4+Po/UDgZAREREJlAqldrgx93d3Wyvo1KpkJeXB3t7e6sNgMrbPwcHBwDAvXv34Onp+UjTYdb3zhIREZmBJufH0dHRwi2p2TTv/6PmYDEAIiIiKgNrzMupTirq/WcARERERDUOA6BKII3+Boiabfxg1Gxg/8zKbRAREVENxwCoMkhkwP6vC4Og/TPV30fNVpdLdZK4GBAREVk1pUog5moytp++g5iryVCqhNlfc9iwYZBIJAaP2NhYAOqbf7/55pvw9fWFra0t/P39MXbsWCQnJxu93oYNGyCTyTB69Gijxx88eIBx48bB398ftra28PX1xZtvvombN28arT9z5kzIZDJ8++23FdNhE3AVWCVQdZmgzlTf/zWQeR9w9FB/DwDdPwO6TlQHPTcPA3HR6jJdUbMBlRLoPrnyG09ERBVm17l4hP/vP8Sn5mjLfFzsMbVvC/R6/NGWdZemV69eWLlypV5Z3bp1ce3aNQQFBaFJkybYsGEDAgICcP78eXz88cfYuXMnjhw5Ajc3N73zli9fjokTJ+LHH3/E3LlzYW9vrz324MEDPPXUU7C1tcXSpUvRsmVLXL9+HZ9//jk6dOiAQ4cOwcPDQ+96K1aswMSJE7FixQp8/PHH5nsTdHAEqLJ0nQg06Q0c+wmInFFY/uAakJteGPwEBKvrahgbJSIiompn17l4jPrlpF7wAwAJqTkY9ctJ7DoXb9bXt7Ozg7e3t95DM4pja2uLPXv2oGvXrmjQoAF69+6Nffv24c6dO/jsM/3/KY+Li8Phw4cxadIkNGnSBFu2bNE7/tlnn+Hu3bvYt28fevfujQYNGiA4OBi7d++GXC7HmDFj9OpHRUUhOzsb06dPR1paGg4fPmzW90GDAVBl8utgWPbvBmBmfXXw49FM/VUzDba6rzr40YwSaXCajIjI4oQQyMrLN+mRnqPA1D/Ow9hkl6Zs2h//IT1Hgay8fGTnKUu8nhAVM2324MED7N69G++99552jx0Nb29vvP7669i0aZPe661cuRLPPfccXFxcMHjwYCxfvlx7TKVSYePGjXj99dfh7e2tdz0HBwe899572LNnDx4+fKgtX758OQYNGgS5XI5BgwbpXc+cOAVWmVQF9zyRygGVAvBsCdw7X3g86WJhvpBECghV8SNCRafJiIioUmUrlGgxZXeFXEsASEjLwRPT9phU/7/pYXC0Lduf8D///BO1a9fWPu/duzcmTJgAIQSaN29u9JzmzZvj4cOHuH//Pjw9PaFSqbBq1SosXLgQADBw4EB89NFHiIuLQ0BAAO7fv4+UlJQSryeEwLVr1+Dv74+0tDT89ttviImJAQAMHjwYXbp0wXfffafXVnPgCFBl0Q1cpiSpv2qCH6lc/dXBDRAFQZJQqb/GRQMRXxpeQzcoIiIiKkX37t1x+vRp7eP777/XHittRMnW1hYAsHfvXmRmZqJPnz4AAA8PD4SGhmLFihV69U0dodqwYQMCAwPRunVrAECbNm3g7++PTZs2mdyv8uIIUCWQHpgDRM8qPnDRlO3/Gqj3JHDnhP7xA3OAg/OMjwhpMFGaiKhSOchl+G96mEl1j8U9wLCV/5Rab9XwDmjv74r0tHQ4OTsVe6sIB3nZ80Jr1aqFxo0b65XZ2tpCIpHgwoULeOmllwzOuXDhAurWrQtXV1cA6umqBw8e6E2XqVQqnDlzBuHh4dq6Fy5cMNqGCxcuQCKRoFGjRtrrnT9/HjY2NnrXW7FiBUaMGFHmPpYFR4Aqg1DqBz+6IzndP1MHLl0nqoObOyfUXyffAR7T+cXSGxGarn99JkoTEVU6iUQCR1sbkx5dHqsLHxd7FLeHsQTq1WBdHqsLR1sbONjKSrxeRe2G7O7ujtDQUCxZsgTZ2dl6xxISErBu3ToMGzYMAJCcnIzt27dj48aNeiNJp06dwsOHD7Fnzx5IpVL0798f69evR0JCgt71srOzsWTJEvTs2RN16tTB2bNncfz4cURGRupdLzIyEjExMbh48WKF9LE4DIAqgSr4E/1RG5VOQNR1onrUJmp24SqwBp0Bu9rA678CDYMNL3hgLvDLK4Aih9NiRETVgEwqwdS+LQDAIAjSPJ/atwVk0sq/zcaiRYuQm5uLsLAwREdH49atW9i1axdCQ0PRpEkTTJkyBQCwdu1auLu7o3///nj88ce1j9atW6NPnz7a5OUZM2bA29sboaGh2LlzJ27duoXo6GiEhYVBoVBg0aJFANRL3zt27Ijg4GC96wUHB6NDhw5mT4ZmAGQJ3ScbBiuaoGjo/wqnsaJmA9c1S+M/AVq+XFg/dh/wtVfxwQ9XihERVSm9HvfBD4PbwdvFXq/c28UePwxuZ/Z9gIrz2GOP4Z9//kGjRo3Qv39/+Pv7o3fv3mjSpAkOHTqkTUZesWIFXnrpJaOjT6+88gr++OMPJCUlwd3dHUeOHEH37t3xzjvvIDAwEP3790dgYKD2dfLy8rBu3Tq88sorRtv0yiuvYM2aNY98w9MSCQuaMWOGaN++vahdu7aoW7euePHFF8XFixdLPe/XX38VTZs2FXZ2duLxxx8Xf/31l95xlUolvvjiC+Ht7S3s7e1Fjx49xOXLl01uV2pqqgAgUlNTy9wnXXl5eWLbtm0iLy+v7CdHfiPEVGf1V11/z1SX6z4WdRIiLb70c83gkfpYTbCP1oF9tA6W7GN2drb477//RHZ29iNdJ1+pEodjk8S2U7fF4dgkka9U6R1XKpXi4cOHQqlUPtLrPIopU6aI2rVri5iYmAq/9qP2r6TPoSx/vy06AhQVFYXRo0fjyJEj2Lt3LxQKBXr27InMzMxizzl8+DAGDRqEESNG4NSpU+jXrx/69euHc+fOaevMnj0b33//PZYuXYqjR4+iVq1aCAsLQ05OTrHXrXJUSuMjO90nqUeEAPVSeQC4fwFY0Ao4+hMQ+Q2nxIiIqjCZVIKgQHe82KYeggLdLTLtVZrw8HB8//33OHLkCFQqlaWbYxYWXQW2a9cuveerVq2Cp6cnTpw4geBgI7kvAL777jv06tVLu1X2l19+ib1792LRokVYunQphBBYsGABPv/8c7z44osAgDVr1sDLywvbtm3DwIEDzdupilLcai5NrpAmwPlzPHB8OaDMBXYWbB/u14krxYiI6JEMHz7c0k0wqyq1DD41NRUADO45oismJgbjx4/XKwsLC8O2bdsAqLfoTkhIQEhIiPa4i4sLOnXqhJiYGKMBUG5uLnJzc7XP09LSAAAKheKR5h8151bUHKb0wBzIomdBGTwJqs4fAgoFEPYNpA4ekB34prDiraNQbhwC1SsrjJ9bgXOqFd3Hqoh9tA7so3WwZB8VCgWEEFCpVGYdFREFe+hoXsvaPGr/VCoVhBBQKBTq+2zqKMvPRZUJgFQqFcaNG4enn34ajz/+eLH1EhIS4OXlpVfm5eWlXW6n+VpSnaJmzpyJ8PBwg/I9e/bA0dGxTP0wZu/evY98DQBoGn8RwudlXE5vAezYoS1vknAFzQEISCAp2FRddvEPZMxti4OPfYpGSXvRPH4LLhg5t6JUVB+rMvbROrCP1sESfbSxsYG3tzcyMjKQl5dn9tdLT083+2tYUnn7l5eXh+zsbERHRyM/P1/vWFZWlsnXqTIB0OjRo3Hu3DkcPHiw0l978uTJeqNKaWlp8PPzQ8+ePeHs7Fzu6yoUCuzduxehoaGQy+UV0FL1zpu621hJD8yB7NQW9chOlwmQRs+G7MBsCAAuObfQ5+woSAAogyehcZcJBudCKNXL9Mup4vtY9bCP1oF9tA6W7GNOTg5u3bqF2rVr6939vKIJIZCeng4nJ6cK2++nKnnU/uXk5MDBwQHBwcEGn4NmBscUVSIAGjNmDP78809ER0ejfv36Jdb19vZGYmKiXlliYqL2pmuar4mJifDx8dGr06ZNG6PXtLOzg52dnUG5XC6vkF+wirqOgajZ2h2mZV0nQgYAPT4DbOSQ7P8aQOH+ErJ75yDTbYPuuVW5j1UI+2gd2EfrYIk+KpVKSCQSSKXSYndorgiaaSHNa1mbR+2fVCqFRCIx+jNQlp8Ji76zQgiMGTMGW7duxd9//42AgIBSzwkKCkJERIRe2d69exEUFAQACAgIgLe3t16dtLQ0HD16VFvHahS3UkyzqzQAaKLri38CP3bl5olERESw8AjQ6NGjsX79emzfvh1OTk7aHB0XFxftfUbeeOMN1KtXDzNnqjf1Gzt2LLp27Yq5c+fiueeew8aNG3H8+HH89NNPANQR5bhx4/DVV1/hscceQ0BAAL744gv4+vqiX79+Fumn2ZiyUqzLBGBtPyAuCog/DXztDUAw+CEiohrNoiNAP/zwA1JTU9GtWzf4+PhoH7p3gb158ybi4+O1zzt37oz169fjp59+QuvWrfHbb79h27ZteonTEydOxPvvv4+3334bHTp0QEZGBnbt2mXWOdsqo+jojlQKDP0DaKVZ/VZwh970+BLO5w7SRERk3Sw6AqRZCleSyMhIg7LXXnsNr732WrHnSCQSTJ8+HdOnTy+2jtUqblrMPVD/+fEVQE4a8KrOvVZ0gyciIiIrZn3ZVTWdsfuM6QY2k24Bbo3U5ed+A9a+DAjBvCAiIit369YtvPnmm/D19YWtrS38/f0xduxYJCcnG9TdsGEDZDIZRo8ebfRaDx48wLhx4+Dv7w9bW1v4+vrizTffxM2bN43WnzlzJmQyGb799tsK7dOjYABk7YoGNvbOwOh/AN926uNXI4Dpbgx+iIjMbf9M9b/Jxpg5/eDatWto3749rly5gg0bNiA2NhZLly5FREQEgoKC8ODBA736y5cvx8SJE7FhwwaD20g9ePAATz31FPbt24elS5ciNjYWGzduRGxsLDp06IBr164ZvP6KFSswceJErFixwuCYpTAAsnbGpsRkNsDIv4HGBbtlC5X6vmKdP7BMG4mIagKpTP0/m0WDIM3/qEplxs+rAKNHj4atrS327NmDrl27okGDBujduzf27duHO3fu4LPPClMf4uLicPjwYUyaNAlNmjTBli1b9K712Wef4e7du9i3bx969+6NBg0aIDg4GLt374ZcLjcYNYqKikJ2djamT5+OtLQ0HD582Gz9LAsGQNbO2JQYoF4e79ep8LlQAXObALlGduZkYjQRkSEhgLxM0x9Bo4Hgj9XBzt9fqcv+/kr9PPhj9XFNXUVWydcyIYdW48GDB9i9ezfee+897QprDW9vb7z++uvYtGmTNi935cqVeO655+Di4oLBgwdj+fLCXFGVSoWNGzfi9ddf1+67p+Hg4ID33nsPu3fv1htRWr58OQYNGgS5XI5BgwZVmVGgKrERIlmA7tRYg6eANf2AnFRgbjNg7L9ALQ/DekREVEiRBczwLd+50d+qH0aeSwG4lnb+p3cB21omvdSVK1cghEDz5s2NHm/evDkePnyI+/fvw8PDA6tWrcLChQsBAAMHDsRHH32EuLg4BAQE4P79+0hJSSnxWkIIxMbGomPHjkhLS8Nvv/2GmJgYAMDgwYPRpUsXTJ8+/ZHutFAROAJUExXNCwoIBkZGAFIbIC8DmP84kHKLidFERFaktJXXtra22Lt3LzIzM9Gnj/rWSx4eHggNDTUYtTFlFTegTqYODAxE69atAQBt2rSBv78/tm7dWo4eVCyOANVExvKCfNsC7x0BfngayM8GFhTsq8Tgh4jIOLmjeiSmrA7OV4/2yGwBZZ56+uuZD7WHVSoV0tLT4ezkVPytIuSm36i7cePGkEgkuHDhAl566SWD4xcuXEDdunXh6uqK5cuX48GDB3pTZSqVCmfOnEF4eLi23oULF4y+1oULFyCRSNC4sfrOk8uXL8f58+dhY2Ojd71ffvml2BVmlYUjQDVRcXlBHo8BH5zSL3viVcN6zAkiIlLnUtrWKtsjZrE6+On+GfDFffXX6G/V5br15I4lX6cMNxF1d3dHaGgolixZguzsbL1jCQkJWLduHYYNG4bk5GRs374dGzduxOnTp7WPU6dO4eHDh9izZw+kUin69++P9evXa+/eoJGdnY0lS5YgLCwMbm5uOHv2LI4fP47IyEi96/3999/4559/cPHixQr5GMqLARDpO71O//niTkBSbOHzSlitQERklYylFXSdqH5ubHVYBVq0aBFyc3MRFhaG6Oho3Lp1C7t27UJoaCiaNGmCKVOmYO3atXB3d0f//v3x+OOPax+tW7dGnz59tMnQM2bMgLe3N0JDQ7Fz507cunUL0dHRCAsLg0KhwOLFiwGoR386duyI4OBgvesFBwejXbt2Fk+GZgBEhXR/OSdcUf8fiDIP+CEIuH+ZOUFERI+ipBtYd/9MfdxMHnvsMfzzzz9o1KgR+vfvD39/f/Tu3RtNmjTBoUOHULt2baxYsQIvvfQSJEZGl1555RX88ccfSEpKgru7O44cOYLu3bvjnXfeQWBgIPr374/AwEDta+Tl5eGXX37BK6+8YrQ9ffv2xdq1a6FQKMzW59IwB4jUjAU3484CC55Qr3RY3EFdxuCHiKh8iruBNVAp/642bNgQq1at0j6fOnUq5s2bhzNnzuCpp57CmTNnij23f//+6N+/v/a5h4cHvv/+e3z//fdG69va2iIpKanY640dOxZffPFF8TlOlYAjQKRm7P9MankAH57Xr2csJ4iIiKqd8PBwfP/99zhy5AhUKpWlm1PpOAJEasX9n8k/Pxd8IwEggMVPAe+fAFz99KpJD8xRVynp/3CIiKhKGT58uKWbYDEcAaLi6U6LfXQJsHEAlLnAovZAWry2WpOEbZBFz2JiNBERVRsMgMi4ojlBTl7qkR8bOyA/B1jYFsi4D+mBOWgevwXK4EnMDSIiomqDARAZZywnyKWe+k7yMjtAkQ3MeQyy6Fm44PMyVF0mWK6tRESVyNRdkMk8Kur9ZwBExhW3WWIdf+C9mIInAgISxHr2qdSmERFZglwuBwBkZWVZuCU1m+b913we5cUkaCq7c79rv5VAoNvFL4DezwG6P4xRswtGkZgUTUTWQSaTwdXVFffu3QMAODo6Gt0z51GpVCrk5eUhJyfHosvEzaW8/RNCICsrC/fu3YOrqytkskfLO2UARGWjmxuUcgM49QuccuOhWhEKvHsAkEp5B3kislre3t4AoA2CzEEIgezsbDg4OJglwLK0R+2fq6ur9nN4FAyAyHRGNktU5mVDdv53SO+dA1aEAY1DgMgZ3DCRiKySRCKBj48PPD09zbaLsUKhQHR0NIKDgx95mqcqepT+yeXyRx750WAARKYzkhit6vcjEm/fgG/qceD2MfWDwQ8RWTmZTFZhf4iNXTs/Px/29vZWGQBVlf5Z3+QimU8xidH/NPoAQqLzD0GdgEpsFBERUdkxAKJH1iRhGyRCCUgKfpy2jASuRRpWjJoN7J9ZqW0jIiIyhgEQPRK9jRC/SAYcPQAIYO3LQMK5woqa/CHuFk1ERFUAAyAqv6jZ+hshSqXqm6fauQBCCSzrDqTcMn6neSIiIgtiEjSVn0oJZfAkXE5vgcaaMrk9MO4MMK85oMgCFjwBQDD4ISKiKoUjQFR+3ScbvwWGgysw5p+CJwKABHjmw0psGBERUckYAJF5nF6v80QAP/cAit6/hUnRRERkIQyAqOLp5vw80V9dFv8vsLafYR0mRRMRkQUwB4gqlrGE55wU4Moe9dL4X4cCXi2ZFE1ERBbFESCqWEZ2i8brm4H6HdXf/7eNwQ8REVkcR4CoYhV39/c3dwFfegBCpX7eemDltYmIiKgIjgBR5TgwtyD4Kbjz77Jngdx0izaJiIhqLgZAZH66eUEfngOkciDzPvBjN/WUmUFdrgwjIiLzYgBE5lU0KdqlPtB2sPrYg1hgZW/DulwZRkREZsYcIDIvY0nRfRcA2Q/VCdG3jgInVgMZiUyOJiKiSmPREaDo6Gj07dsXvr6+kEgk2LZtW4n1hw0bBolEYvBo2bKlts60adMMjjdr1szMPaFidZ9sPKDpvxpoGKz+/n8fMPghIqJKZdEAKDMzE61bt8bixYtNqv/dd98hPj5e+7h16xbc3Nzw2muv6dVr2bKlXr2DBw+ao/n0qIb+AUh0fgRbDbBcW4iIqEax6BRY79690bt379IrFnBxcYGLi4v2+bZt2/Dw4UMMHz5cr56NjQ28vb0rrJ1kJtHfFi6LB9S3y/jgFGDnVFgWNbtgGq2Y5fVERETlUK1zgJYvX46QkBD4+/vrlV+5cgW+vr6wt7dHUFAQZs6ciQYNGhR7ndzcXOTm5mqfp6WlAQAUCgUUCkW526c591GuUdWVt4/SA3Mgi54FZfAkIDcdsqOLgcz7UP3UHcp3DgESqV4dlQXfQ36O1oF9tA7sY/Vnzv6V5ZoSIYreodIyJBIJtm7din79+plU/+7du2jQoAHWr1+P/v37a8t37tyJjIwMNG3aFPHx8QgPD8edO3dw7tw5ODk5Gb3WtGnTEB4eblC+fv16ODo6lqs/VLwmCdvQPH4LLvi8jMve/QAArW+uQMPkSABAUq2muO/c0qAOERFRSbKysvB///d/SE1NhbOzc4l1q20ANHPmTMydOxd3796Fra1tsfVSUlLg7++PefPmYcSIEUbrGBsB8vPzQ1JSUqlvYEkUCgX27t2L0NBQyOXycl+nKitPH6XR3wASGVRdJuiX/zYMskt/ap8rgycZ1LEEfo7WgX20Duxj9WfO/qWlpcHDw8OkAKhaToEJIbBixQoMGTKkxOAHAFxdXdGkSRPExsYWW8fOzg52dnYG5XK5vEI+nIq6TlVWpj72+BwAYLDbz6B1QHgdbV6QrHkfyKrQ+8bP0Tqwj9aBfaz+zNG/slyvWm6EGBUVhdjY2GJHdHRlZGTg6tWr8PHxqYSW0SOJmq1/u4xVzwMZ9y3aJCIisk4WDYAyMjJw+vRpnD59GgAQFxeH06dP4+bNmwCAyZMn44033jA4b/ny5ejUqRMef/xxg2MTJkxAVFQUrl+/jsOHD+Oll16CTCbDoEGDzNoXekS6O0Z/ch2wsQdy04Bl3YH8PCN1ebsMIiIqP4sGQMePH0fbtm3Rtm1bAMD48ePRtm1bTJkyBQAQHx+vDYY0UlNT8fvvvxc7+nP79m0MGjQITZs2Rf/+/eHu7o4jR46gbt265u0MlV/R22U4uALthqqPpd4CVoQZ1uXtMoiI6BFYNAeoW7duKCkHe9WqVQZlLi4uyMrKKvacjRs3VkTTqDIZu11Gn9nq22Wc/RW4exI4vgLITOKO0UREVCGqZRI0WZniNjl8ZRmQeQ+4Fgn8+WFBXQY/RET06KplEjTVIEO26d8uo83rFmsKERFZDwZAVLVpb5dRsDJscUdAkWNYj4nRRERUBgyAqOrSTY4eexqQ2gB5GcB3TwC6uWNMjCYiojJiAERVU9GVYXUaAoN/Vx/LuAcsfNJ4PSIiIhMwAKKqydjKsEbdgLAZ6u8fXAWmuzP4ISKicuEqMKqailsZ9tR7QPwZ4MxGQJUPyOQMfoiIqMw4AkTVi0QCuDYofK5UAH9/bbn2EBFRtcQAiKqXqNlA9GwgaAxg46Aui54NRH5jWI+rwoiIqBgMgKj60E14DvsaePzlwmORM9THdetxVRgRERWDARBVH0UTo/stARqHFh5PvspVYUREZBImQVP1YSwx+vXNwI9dgISz6sRogMEPERGViiNAVL1JJMCIvdDuFA2JOj+IiIioBAyAqPo7vBCAZmdoAfwcor9TNBERUREMgKh60835GfqnuuzeeeCXV4qpy5VhRETEAIiqs6IJzwFdCpOir0YA20YZ1uXKMCIiAgMgqs6M3S7j9c2A9xPq78/8Cjy8wZVhRERkgKvAqPoytipMkxT9XRsgIwH4rjUAweCHiIj0cASIrI/cAXhrX8ETAUikQPDHFm0SERFVLQyAyDr9u6Hwe6FiUjQREelhAETWRzfn57Ge6rKrEcDWdw3rMCmaiKhGYg4QWZeiCc9CAD8GAwln1KNCDnXUDyZFExHVaAyAyLoUXRmmSYr+vg2QHg8cWaIuZ/BDRFSjMQAi62JsZZjcHngrApjfQv2cSdFERDUec4CoZji9rvB7oQLW9rNYU4iIyPIYAJH1080Len6+uuxaJLDl7WLqcmUYEZG1YwBE1q1oUnT7NwHftupjZzYBOz8xrMuVYUREVo8BEFk3Y7fLeHMP4Fxf/f2J1UBOGm+XQURUwzAJmqybsaRoG1tg5N/AwieBvHTgG391XhCDHyKiGoMjQFQzOXkBQ7ervxcqQCJj8ENEVIMwAKKaKzai8HuhBDYPs1hTiIiocjEAoppJN+enfgd12fmtwF8fGdSTRn9T+e0jIiKzYgBENU/RhOfAkMJj//wM7J2mX0/CVWFERNaGSdBU8xRdGdZ9EqDMAQ4W7BF07nfAxg6ImgV0/wyqzh8CO3ZYrr1ERFThGABRzWNsZVjINCAvEzj2E5B6Uxv8oOtEQKGo9CYSEZF5WXQKLDo6Gn379oWvry8kEgm2bdtWYv3IyEhIJBKDR0JCgl69xYsXo2HDhrC3t0enTp1w7NgxM/aCrEafbwGpzv8TOLpbri1ERGRWFg2AMjMz0bp1ayxevLhM5126dAnx8fHah6enp/bYpk2bMH78eEydOhUnT55E69atERYWhnv37lV088naRM0GVPmFOT9/fQTEHTBej7fLICKq1iwaAPXu3RtfffUVXnrppTKd5+npCW9vb+1DKi3sxrx58zBy5EgMHz4cLVq0wNKlS+Ho6IgVK1ZUdPPJmugmRk9JBmrVBSDUN019eN2wHm+XQURUrVXLVWBt2rSBj48PQkNDcejQIW15Xl4eTpw4gZCQwlU9UqkUISEhiImJsURTqToouipMIgHGnQVsawOqfNgsC4aNMhvSA3N4uwwiIitRrZKgfXx8sHTpUrRv3x65ubn4+eef0a1bNxw9ehTt2rVDUlISlEolvLy89M7z8vLCxYsXi71ubm4ucnNztc/T0tIAAAqFAopHSIDVnPso16jqrKGP0vw8IHiSerWXth82wDsxsFncDhJFFvqceRcSCCgN6lkHa/gcS8M+Wgf2sfozZ//Kck2JEEJUeAvKQSKRYOvWrejXr1+ZzuvatSsaNGiAtWvX4u7du6hXrx4OHz6MoKAgbZ2JEyciKioKR48eNXqNadOmITw83KB8/fr1cHR0LFN7yLrUybyKLpfDIQGgghT/a7vK0k0iIqJiZGVl4f/+7/+QmpoKZ2fnEutWqxEgYzp27IiDBw8CADw8PCCTyZCYmKhXJzExEd7e3sVeY/LkyRg/frz2eVpaGvz8/NCzZ89S38CSKBQK7N27F6GhoZDL5eW+TlVm7X2UHpgDyeWC76HC81m/QvXqKou2yRys/XME2EdrwT5Wf+bsn2YGxxTVPgA6ffo0fHx8AAC2trZ48sknERERoR1JUqlUiIiIwJgxY4q9hp2dHezs7AzK5XJ5hXw4FXWdqswq+xg1G4ieBWXwJKSc2AL3zMuQXfoTsp3jgRcW6tdTKY3vL1TNWOXnWAT7aB3Yx+rPHP0ry/UsGgBlZGQgNjZW+zwuLg6nT5+Gm5sbGjRogMmTJ+POnTtYs2YNAGDBggUICAhAy5YtkZOTg59//hl///039uzZo73G+PHjMXToULRv3x4dO3bEggULkJmZieHDh1d6/6ga00mMVnX+EPcuX4J7ZsFQ0Mk1gJ0TEDZDP4GaiIiqDYsGQMePH0f37t21zzXTUEOHDsWqVasQHx+Pmzdvao/n5eXho48+wp07d+Do6IhWrVph3759etcYMGAA7t+/jylTpiAhIQFt2rTBrl27DBKjiUqke7sMhQKXfV5Ck8AAyA7NUx//91fAxgE4MIerwoiIqiGLBkDdunVDSTnYq1at0ns+ceJETJxY+h+aMWPGlDjlRVQqI9NZqm6fQqbKA2IWAVn31cFPt8kMfoiIqqFquQ8QkcWEfQ1IdeaYc9Mt1xYiIio3BkBEZRE1G1ApCu8ZFrMIOL7SeD3eLoOIqMpiAERkIr2doKckA67+6gN/jgOu7i+syNtlEBFVeQyAiEzQJGEbZNGz9BOex/5bcM8wAL+8Aty/bHhbDSIiqpKq/T5ARJVBIlRQBk+CTDeokUiAceeAOY8BuWnA4g7qcgY/RERVHkeAiExwyedlqLpMMDwgtwc+OKVTIAE6f1Bp7SIiovJhAET0qI6v0HkigPktAZXKsB4To4mIqgwGQESPQjfnZ+j/AEiArCTgu1bG6zExmoioSmAARFReRROeA4KBFxerj6XeAhZ2MF6PiIgsjknQROWle7sMjbavAw/jgOhvgeTLwHR3QJXP4IeIqIphAERUXsXd/b37Z8DD68DZzergRypn8ENEVMVwCoyookkkgFujwucqBbD7c8N6TIomIrIYBkBEFS1qNhD1DfDMh4Cju7osZiEQMV2/DpOiiYgshlNgRBWpaMLzk8OBJUGAIhM4MFc9HSaVMSmaiMjCGAARVaSiidF1/IHhfwE/h6qnwqK+ASAY/BARWRgDIKKKZCwx2rctMHAdsL4/AAFIZAx+iIgsjDlARJUh/t/C74USWD/Qcm0hIiIGQERmp5cX9Im67PJO4Le3iqnLlWFERObGAIjInIomRXebDPi0Vh87txn44wPDulwZRkRkdgyAiMypaFK0RAK89TfgFqh+fnodkHSFt8sgIqpkTIImMidjSdEyG+DdA8DC9kD6XWBR+4K6DH6IiCoLR4CILMG2ljoI0pIAHUdarDlERDUNAyAiSzm+QueJAH54BsjL0q/DpGgiIrNgAERkCbo5Px0KVoOl3QZ+7AIo8/XrMCmaiKjCMQeIqLIZS3jOzwVOrQWSY4Fl3YFmzwORM5gXRERkJgyAiCpb0ZVhAPDiIkCRo14an3BG/ej2KYMfIiIzYQBEVNmMrQwDgFd/Bv7bCqgKpsBk8sprExFRDcMcIKKqImq2OviRFOT8RIQXSZTWqcfEaCKiR8IAiKgq0M0LmvoAcGmgLv/zQ+Dc74b1mBhNRPRIOAVGZGnGkqLHnQHmNQfS44HfRgB2LsDdk9wtmoiogjAAIrI0Y0nREgnw4X/A3CZA5n1g3SvqcgY/REQVggEQkaUVlxQtlaqDoK89ASHUZY1DDOtFzS4Iooq5DhERGWAOEFFVdmhBYfADAMtDgcT/Cp8zJ4iIqFwYABFVVbq5QZNvA7ZO6lViPwUDyVd5B3kiokfAKTCiqqi4xOj5jwOKTGBhO3UZgx8ionLhCBBRVWQsMdrRDRh7Wr9e2yGV2iwiImth0QAoOjoaffv2ha+vLyQSCbZt21Zi/S1btiA0NBR169aFs7MzgoKCsHv3br0606ZNg0Qi0Xs0a9bMjL0gMoPuk42P7JxYpf98YVsg475hPW6WSERUIosGQJmZmWjdujUWL15sUv3o6GiEhoZix44dOHHiBLp3746+ffvi1KlTevVatmyJ+Ph47ePgwYPmaD5R5dKdFhv7LyCzBRTZwHetgawHhvWYGE1EVCyL5gD17t0bvXv3Nrn+ggUL9J7PmDED27dvx//+9z+0bdtWW25jYwNvb++KaiaR5RnLCRoVA/zwlDonaMETwPj/gKM/MjGaiMgE1ToHSKVSIT09HW5ubnrlV65cga+vLxo1aoTXX38dN2/etFALiSqIsZwgj8bAOwcBqQ2QlwHM8mfwQ0Rkomq9CmzOnDnIyMhA//79tWWdOnXCqlWr0LRpU8THxyM8PBxdunTBuXPn4OTkZPQ6ubm5yM3N1T5PS0sDACgUCigUinK3T3Puo1yjqmMfK8kzEzSN0S+vEwi8uQ82P3eDBAICEuS3H2lYrxRVoo9mxj5aB/ax+jNn/8pyTYkQurusWY5EIsHWrVvRr18/k+qvX78eI0eOxPbt2xESYmR33AIpKSnw9/fHvHnzMGLECKN1pk2bhvDwcKOv4ejoaFJ7iCylScI2NI/fAgFAAiDT1h37m82CUmanV0ciVLjk87LF2klEZG5ZWVn4v//7P6SmpsLZ2bnEutVyBGjjxo146623sHnz5hKDHwBwdXVFkyZNEBsbW2ydyZMnY/z48drnaWlp8PPzQ8+ePUt9A0uiUCiwd+9ehIaGQi6Xl/s6VRn7aFnSA3MgO7UFyuBJQPpdyE6tQa28ZPS58SWU7xwE5I56dQK79DF6narcx4rCPloH9rH6M2f/NDM4pqh2AdCGDRvw5ptvYuPGjXjuuedKrZ+RkYGrV69iyJDi90uxs7ODnZ2dQblcLq+QD6eirlOVsY8WEDUbiJ4FdP8MMk3Oj0QKnFwFaepNSJcFA0/0B6Jna+uUti6syvXRDNhH68A+Vn/m6F9ZrleuJOjp06cjKyvLoDw7OxvTp083+ToZGRk4ffo0Tp8+DQCIi4vD6dOntUnLkydPxhtvvKGtv379erzxxhuYO3cuOnXqhISEBCQkJCA1NVVbZ8KECYiKisL169dx+PBhvPTSS5DJZBg0aFB5ukpUdRlLjH7hO6Bdwe/Mw+vq4Cd4IpOiiYiKKFcAFB4ejoyMDIPyrKwso7k0xTl+/Djatm2rXcI+fvx4tG3bFlOmTAEAxMfH663g+umnn5Cfn4/Ro0fDx8dH+xg7dqy2zu3btzFo0CA0bdoU/fv3h7u7O44cOYK6deuWp6tEVVdxmyW+sFC9Mkzj7K9AnuH/sHCzRCKqyco1BSaEgEQiMSj/999/DZakl6Rbt24oKQd71apVes8jIyNLvebGjRtNfn0iqxQ1W33TVKkcUCnUI0FLgoD3YgBbx8I6miXzREQ1UJkCoDp16mhvL9GkSRO9IEipVCIjIwPvvvtuhTeSiExUdMPEP94HTq4BUq4DS54C3jsCxCzifkFEVOOVKQBasGABhBB48803ER4eDhcXF+0xW1tbNGzYEEFBQRXeSCIygbHdol9YqP56cg2QcgOY4QtAMPghohqvTAHQ0KFDAQABAQF4+umnYWNT7RaREVkvY0nRgH4QpNkt6KlRld06IqIqpVxJ0E5OTrhw4YL2+fbt29GvXz98+umnyMvLq7DGEVEZFJcUDQAufjpPBDCvOZCTalBNemAOE6OJqEYoVwD0zjvv4PLlywCAa9euYcCAAXB0dMTmzZsxcSKH1YmqFN2psbcj1SvEctOBeS2A7Ifaak0StkEWPYt3kSeiGqFcAdDly5fRpk0bAMDmzZvRtWtXrF+/HqtWrcLvv/9eke0jokdRNC/It21hEJSXAcxvCWQmQ3pgDprHF+wozdwgIqoByhUACSGgUqkAAPv27UOfPurt9f38/JCUlFRxrSOiR2MsL8j7CeCdA+pl8nmZwLeBkEXPwgWfl6HqMsFybSUiqkTlCoDat2+Pr776CmvXrkVUVJT2lhRxcXHw8vKq0AYS0SMoLi/IqwUw6nDBEwEB4KZbF8N63CyRiKxUuQKgBQsW4OTJkxgzZgw+++wzNG7cGADw22+/oXPnzhXaQCIyk/+2ab+VAOjx30T1pokamukz5gQRkRUq1zr2Vq1a4ezZswbl3377LWQy/mNJVOXp5ga1HgSxqD1s8nMgfuwMvHtIHRxxs0QismKPtJHPiRMntMvhW7RogXbt2lVIo4jIjIxsmJj/3nFgUTvIlXnA4g7qegx+iMiKlSsAunfvHgYMGICoqCi4uroCAFJSUtC9e3ds3LiRNx4lqsqMJUY7eWNfy/nodXY0tDe4Sb1t/Pyo2QXXmGzulhIRmU25coDef/99ZGRk4Pz583jw4AEePHiAc+fOIS0tDR988EFFt5GIKlIxidENkyIKgp+CEOjkamBbkR2jmRdERFaiXAHQrl27sGTJEjRv3lxb1qJFCyxevBg7d+6ssMYRUeXQ2wfo0ztAnQD1gdPrgd/eUn9v7F5jRETVVLmmwFQqFeRyuUG5XC7X7g9ERNVE1GztPkCNu0yATC4HRh8FlnYBki4B5zYD/20FVPkMfojIapRrBOjZZ5/F2LFjcffuXW3ZnTt38OGHH6JHjx4V1jgiqgQqJZTBk3DZu19hmY2dep8g7ycK6uQDEhmDHyKyGuUKgBYtWoS0tDQ0bNgQgYGBCAwMREBAANLS0rBw4cKKbiMRmVP3ycZ3gJbZAM36Fj4XSmDV84AQ+vW4WSIRVUPlmgLz8/PDyZMnsW/fPly8eBEA0Lx5c4SEhFRo44jIgqJmA5EzgG6fAtcPAtejgesHgOWhwJt7AKlUPy+IiKgaKdMI0N9//40WLVogLS0NEokEoaGheP/99/H++++jQ4cOaNmyJQ4cOGCuthJRZdENbLp9Agz7H/BYT/Wx2/8AP3ZRj/owKZqIqqkyBUALFizAyJEj4ezsbHDMxcUF77zzDubNm1dhjSMiCzG2V9Drm4HmL6q/TzwHRM0Cgj9m8ENE1VKZAqB///0XvXr1KvZ4z549ceLEiUduFBFZWHE3UR2wBpDqzJyfXg9kPTCsx7wgIqriyhQAJSYmGl3+rmFjY4P79+8/cqOIqIqKmq1eESYt+Hcg7Q6wqAOQeke/DjdLJKIqrkwBUL169XDu3Llij585cwY+Pj6P3CgiqoJ084KmJAEd31aXZyUBS54C7l/mZolEVG2UKQDq06cPvvjiC+Tk5Bgcy87OxtSpU/H8889XWOOIqIowFtj0+RYIGq3+PjdNfRNVBj9EVE2UaRn8559/ji1btqBJkyYYM2YMmjZtCgC4ePEiFi9eDKVSic8+43JYIqtjLCkaAMJmAFJb4ND8wjLvVobn8waqRFTFlCkA8vLywuHDhzFq1ChMnjwZomBDNIlEgrCwMCxevBheXl5maSgRWVBJgYuto/7zDQOAFxYB7Yaon3OvICKqgsq8EaK/vz927NiBhw8fIjY2FkIIPPbYY6hTp4452kdEVZlucPPMh8D8lkBGIvDHGCA9ARAq9WaKnBYjoiqmXDtBA0CdOnXQoUOHimwLEVUnxvKCProELHgCSL0F7P9KXda1mCX1REQWVK57gRERGc0LkkiAD8+pv2qc+w3IyzQ8n3sFEZEFMQAiovIpbrPEqNnqG6ZqNkxMvgIsbA9kJunX4V5BRGRBDICIqOLo7RWUDLR7Q12efhdY1B5Ivsq9goioSih3DhARkR5jgc0LCwG5I3B0KZD9EFjYTl3O4IeILIwjQERUMYrbK6j3N0Dnsfplns0Nz2dOEBFVIgZARFQxissJAgC72vrPNw0GYpYUPmdOEBFVMk6BEZF56e0VNB5Y8DiQHg/sngyk3AAc6gCRMzktRkSVigEQEZmPsbyg8ReA79sCD+PUuUEAEPwxgx8iqlQWnQKLjo5G37594evrC4lEgm3btpV6TmRkJNq1awc7Ozs0btwYq1atMqizePFiNGzYEPb29ujUqROOHTtW8Y0notIVt1fQ2NOAROefn5NrgbR4w/OZF0REZmLRACgzMxOtW7fG4sWLTaofFxeH5557Dt27d8fp06cxbtw4vPXWW9i9e7e2zqZNmzB+/HhMnToVJ0+eROvWrREWFoZ79+6ZqxtEVJwS9wpSAVK5+nlGArC4I5B4Xr8O84KIyEwsGgD17t0bX331FV566SWT6i9duhQBAQGYO3cumjdvjjFjxuDVV1/F/PmFd6KeN28eRo4cieHDh6NFixZYunQpHB0dsWLFCnN1g4jKQm+voCTgqVHq8tw04KduQOw+7hVERGZXrXKAYmJiEBISolcWFhaGcePGAQDy8vJw4sQJTJ5ceOdqqVSKkJAQxMTEFHvd3Nxc5Obmap+npaUBABQKBRQKRbnbqzn3Ua5R1bGP1qGy+ig9MAey6FlQBk+CqvOHgEIB9PgSUqktZIe/A5R5EL+8AgmgX6cC8HO0Duxj9WfO/pXlmtUqAEpISICXl5demZeXF9LS0pCdnY2HDx9CqVQarXPx4sVirztz5kyEh4cblO/ZsweOjo6P3O69e/c+8jWqOvbROpi7j03jL0L4vIzL6S2AHTt0jjyJpt790DRhGzR3EUs9vhkH0prp5woBaJKwDRKhwiWfl8vVBn6O1oF9rP7M0b+srCyT61arAMhcJk+ejPHjx2ufp6Wlwc/PDz179oSzs3O5r6tQKLB3716EhoZCLpdXRFOrHPbROlReH/sAABobOSI98B8kCYCQyCARSrhlXUXfG9OhHBEB2DkV1JkD2aktUAZPQmCXPmV6ZX6O1oF9rP7M2T/NDI4pqlUA5O3tjcTERL2yxMREODs7w8HBATKZDDKZzGgdb2/vYq9rZ2cHOzs7g3K5XF4hH05FXacqYx+tg8X6GDUbiJ4FdP8Mkq4Tgc3DgfNbIH14DdIfOgIj/wb+3aitI+s6EeVNjebnaB3Yx+rPHP0ry/Wq1U7QQUFBiIiI0Cvbu3cvgoKCAAC2trZ48skn9eqoVCpERERo6xBRFWMs4fm1lcCTw9XfZ94HFjxRfFI0l8oTUTlYNADKyMjA6dOncfr0aQDqZe6nT5/GzZs3Aainpt544w1t/XfffRfXrl3DxIkTcfHiRSxZsgS//vorPvzwQ22d8ePHY9myZVi9ejUuXLiAUaNGITMzE8OHD6/UvhGRiYq7h1jfBUDQGP2yhLP6z7lUnojKyaJTYMePH0f37t21zzV5OEOHDsWqVasQHx+vDYYAICAgAH/99Rc+/PBDfPfdd6hfvz5+/vlnhIWFaesMGDAA9+/fx5QpU5CQkIA2bdpg165dBonRRFRFdJ9c/DF7F/VXiVS9b9CFP4AVvYBhO4ADc7hUnojKzaIBULdu3SCEKPa4sV2eu3XrhlOnTpV43TFjxmDMmDEl1iGiKk53aqzLBGD188CNQ8DNGOBLd3VAxOCHiMqpWuUAEVENUTQvSCoFhu8Amr+oPi5U6q/ZD0s4n3lBRFQ8BkBEVPUUlxfk/bj+8yNLgG3v6ZcxL4iITFCtlsETUQ1hLC9Id1SozevAsmfV9xA7vQ7ISgb+bxNvoUFEJmMARERVn7HAZuxpdRB07z/g8i4gvA7zgojIZJwCI6Kqz9iUmNwBGHUYaNRN/VyTF/SkkS0vomZDGv2N2ZtJRNUHAyAiqvq6TzY+qiORAP5P65fNbwnc1Vkpqhk9kjAniIgKMQAioupLd2ps9D+AjQOgzFVPjZ35Ve+4qssES7eWiKoQ5gARUfVkLC/oo4vA923Uy+O3jFSXNeyiPq5QGJ6vUpa8ESMRWS2OABFR9WQsL8jBFfj4KgBJYdn1A8Deqfrncqk8UY3HESAiqp6KG7k5MBeAAKQ2gCpfXXZoAaRZDwH0gPTAHO1d5blajKjmYgBERNaj6LTYjo+BYz8BAGSnVqMv1kIKLpUnIk6BEZG1MJYT1OdboMtH2ipSqCAgAZ4eW8z5vH0GUU3BAIiIrENxt8/oMQVoGAwAEAAkEMDsRkDKrcI6zAkiqnE4BUZE1qG4nKCo2cD1aCiDJ+HonXwExS2AJC9DvVrs9d+A2//w9hlENRBHgIjIehXZB+i+cyvkjzoG2NZWJ0iv7ac+3jDYePDDaTEiq8UAiIisl7FpMdcGRpbKRwP7pumfy2kxIqvGKTAisl7FTYsd/h4GS+UPzldvoNj3O95VnqgG4AgQEdUo0gNzCoObKclAh7cKD55YBYS7MfghqgE4AkRENUaThG2QndqiH9w8NxewdynYQBGAUAKQAB3fNrwAb59BZDU4AkRENYZEqKAMnlTiUnk1AcxtAtw5UVjEnCAiq8IRICKqMS75vIzALn1gEMIULJVH98+Axj2Alb2B/FxgWQ+g10wgJw2InMFpMSIrwgCIiGo2o3eVvwwsbAdkJQO7JqnLGgQVv1Se02JE1Q6nwIioZivprvISnaXyN2OA7aP1z+W0GFG1xREgIqrZihu5if4WEAKQygGVQl126hfg4Q1gyDbg4DyuFiOqxjgCRERUlO602JQkoMuEwmPXDwBfeqiPB3AHaaLqigEQEZEuYzlBPb5QP9cS6i9x0er6xs7ntBhRlcYAiIhIV3F3le86UT3iA0DvNhr7vwYipqu/5w7SRNUGc4CIiHSVdFf5uIKl8s98qL6R6vWD6mMH5gKHvlfnCjH4IaoWOAJERFSaoiM7Mjkw7C+g3RuFdVQKABLg6XHFnM+cIKKqhAEQEVFpipsWe2Eh4N9Zp0AAsxsC9y4UFjEniKhK4hQYEVFpSpoWu3FYHRzVbQr89iaQlwksCQJ6fgXkZQCRMzktRlQFMQAiIioPYwnPH54HljwFZD8E9hSsGqvfgTtIE1VBnAIjIioPY9NiTt7AxDj9HaRv/wOsew1QqQrLOC1GZHEcASIiKo/SdpCWyQFlwQ7SV/YA37UGhv4BnN3MpfJEVQBHgIiIKorutNgXSUC3T9XlEimQehP4vo36eLfJhsEPV4oRVSoGQEREFcFYTlC3T9TPhUq/7sk1wL2LhudySoyo0lSJAGjx4sVo2LAh7O3t0alTJxw7dqzYut26dYNEIjF4PPfcc9o6w4YNMzjeq1evyugKEdVUpuwgrQlw0u4AP3RWBz4r+xQ/JcZRISKzsXgAtGnTJowfPx5Tp07FyZMn0bp1a4SFheHevXtG62/ZsgXx8fHax7lz5yCTyfDaa6/p1evVq5devQ0bNlRGd4iopupuZFoL0N9BesoDIOh9dblQqgOfG4eMX4+jQkRmZfEAaN68eRg5ciSGDx+OFi1aYOnSpXB0dMSKFSuM1ndzc4O3t7f2sXfvXjg6OhoEQHZ2dnr16tSpUxndISIqZGxaLOyrwtwgXfu/BvaFF38eEVUoi64Cy8vLw4kTJzB5cuFqCqlUipCQEMTExJh0jeXLl2PgwIGoVauWXnlkZCQ8PT1Rp04dPPvss/jqq6/g7u5u9Bq5ubnIzc3VPk9LSwMAKBQKKBSKsnZLS3Puo1yjqmMfrQP7aB7S/DwgeBJUnT8EdF5XqlJBBkBIpJDo5gcdnAdxcD4kEFAaO+/AHEAooQr+xOjr8XO0DtbeR3P2ryzXlAghRIW3wER3795FvXr1cPjwYQQFBWnLJ06ciKioKBw9erTE848dO4ZOnTrh6NGj6Nixo7Z848aNcHR0REBAAK5evYpPP/0UtWvXRkxMDGQyw+HkadOmITw83KB8/fr1cHR0fIQeEhHpa5KwDc3jt+CCz8u47N1P+zxXVht2ygxtvWseITjr90ax5xGRoaysLPzf//0fUlNT4ezsXGLdar0P0PLly/HEE0/oBT8AMHDgQO33TzzxBFq1aoXAwEBERkaiR48eBteZPHkyxo8fr32elpYGPz8/9OzZs9Q3sCQKhQJ79+5FaGgo5HJ5ua9TlbGP1oF9rBzSA3MgO7UFyuBJaNxlAhoDAPpAeaAJ7KJnAQAEAAmARkn70NA+DcqBmyA99qOR8wxVhT6aG/tY/Zmzf5oZHFNYNADy8PCATCZDYmKiXnliYiK8vb1LPDczMxMbN27E9OnTS32dRo0awcPDA7GxsUYDIDs7O9jZ2RmUy+XyCvlwKuo6VRn7aB3YRzOTAOj+GWRdJ0JvLFozMt2wCyQvLgbWvQokXYb09jFI5wQUHAuG7NnJMBjDNnJLDX6O1sHa+2iO/pXlehZNgra1tcWTTz6JiIgIbZlKpUJERITelJgxmzdvRm5uLgYPHlzq69y+fRvJycnw8fF55DYTEZWbsZViugnPw/4E6vgDY/4BnuivX+96NPC/ccbP5UoxojKz+BTY+PHjMXToULRv3x4dO3bEggULkJmZieHDhwMA3njjDdSrVw8zZ+rvhbF8+XL069fPILE5IyMD4eHheOWVV+Dt7Y2rV69i4sSJaNy4McLCwiqtX0REJilu/yCPxwq+kUA9MQbgxErgznEgoCuQcKZweb3OuU0StkEafRbo8XmlNJ+ourJ4ADRgwADcv38fU6ZMQUJCAtq0aYNdu3bBy8sLAHDz5k1IpfoDVZcuXcLBgwexZ88eg+vJZDKcOXMGq1evRkpKCnx9fdGzZ098+eWXRqe5iIgsytg9xYoug9/zBXD4e/WxhLPqBwD4P60X/EgPzEHz+C1QPjapEhpOVL1ZPAACgDFjxmDMmDFGj0VGRhqUNW3aFMUtXnNwcMDu3bsrsnlERJXH2B5APb8E7JzU5bpuHAI2DAL6rwUOzoMsehYu+LyMxl0mGOYKEZGeKhEAERFRgZJuqXH9gHraS2oDqPLV5Zd2AF96ABBQ+XfBZbd+hqvEjCRKE9V0Ft8JmoiIdJh0S41koKvuNJd6RFx64wDa3FhmeB4TpYkMMAAiIqrqjE2LdZ9ceJNVSLRV/R8cgGzxk8Dt48Cq53mjVaJiMAAiIqrqjE2LaUaEAoKBrp8AnceqqwKQptwAfu6hnjIzhqNCRMwBIiKq8orm7hRzs1SljQNk0bMgIIEEOgtF9n8NpN4GnHyAm4eNLp9nnhDVNBwBIiKqbopJlFZ1mYD7tZurgx+pZkfcgumxk6uBqFnq4KdhsGHwwxEhqmEYABERVTfFJEpLD8xB3YwLUAZPAqYkqYMkCMCntX7F69HA5uHqQIp5QlRDMQAiIrIGUbO1+wCpukxQl3WdqA5s4v9VP5fo/JN/fgsw3Y15QlRjMQeIiMgaqJRQBk/C5fQWxu8W37CL+l5je6cChxboH7OxVwc7uWmAvBbzhKhGYABERGQNuk+GSqEAduwoLDOWLB0aDtw9qQ5wJBJACCA/R33s8EJo7z1WXJ5Q988qq0dEZsUpMCIia1Xa8vngT4BuBaM5Lg0KKhSsHrseDazrD+SmM0+IrBJHgIiIrJWJy+chkRbeZ0wiBYRK/f2V3cDM+oX1NPdg3D+zMDeo6KgQp8momuAIEBFRTVHcfcY0GnYBpj4Enhlv/HjkDGDty0B+tjrwKRpMMXGaqhGOABER1RTGRmWMjQqFTAXuHC/IEyoYEZLKAZUCuBqhfmgo89RfVz2vXlFW3DQZR4WoimEARERUk5WWJ9Sgs3pEZ//XQJPewOVdgO4u09HfAgfmFk6baXCajKo4BkBERDWZqXlCQGGekGY0yN4VyEkpDH5ktuo69y8BboGF9Y1Nk3E1GVkYAyAiIipkSp7QsD8LAxmgcJpMMx127jf9c/Iy1V85TUZVCAMgIiIqZGqekK5uk9UrxCJnAPU7AreP6R8/tAA49B20U2dC90atM/U3Xiz6ugyKyEwYABERUcmKjgoVncbSBCkSieE0WW0vICMRenlDkTOA/7YDQaOBa38Dt46p8426Tiw1d0ianwfgCXP3mGoABkBERFSyoiMw5Zkmk8rU58ls1VNl984D299TH7OxU48AbRoCuPgBRxYXvO5nhUGRZpQoeJL+a3GUiMqJARAREZVNeabJuhYELvu/BtoOAU6vB4RSXZafq/564Q/9c24dA26fAG4cBK4fBAKCoeoyAU2XvwXpgf8AmazwNXVHjooGRAySyAgGQERE9OhMnSYDCkeFNKNBrQaop8oOL4TeVFnsXvUDAGxrA3HRkG4eAjtFLmTRs9TlmtfUHW0qGhBxGT4ZwQCIiIge3aNOkwUEAxCFQVFAV/X9yDQJ03kZAADZ5Z0I0L3O+W3qc5Ku6F9fs3cRYHwqTTdI0gRQKmXhudo+cCTJWjEAIiKiimfqNFnXieql8ZqNF4f+T380RxMQtXgJcPWDOLwQEt1RonvngX1TC59LbdTnSnTu9JR6G8hMAm4cVgdVmoRrzetoXl8zSlTaSJKx6TZOwVU7DICIiKhymLLrdFHBH6u/FowSSSCglNhAJvKBJ/oD534vyCWSADJ54V5EujtTn1ytfgCA3FH9est6AC1eAOo2Uz+v3xF4emzBcn0dxkaSik63GatnSuCkOa/ICJRUAE0SLkMafVZ9vLRRqmKuU2qQZsp5ZqgjPTAHTeMvAuijLrdQgMgAiIiIKoexP3Cm5g4VjNKo/LvgT7eReN7pv8I8IM0o0TMfqXemPvoDIJGpAyNXfyDlRuHrKbLUX+8cVz80bh8DvvJUf+/ors45KjqSdO+COhk7I7GwTHdPI12mBk5GRqBk+79GcwDKxyYVXqekUapirlNqkGbqeRVcRxYXDeHzsrrMgjuDMwAiIiLLMSV3SGeUSNTvBGQUuYbuKBFgPODQJlwPBBp0Av6aUDhyVKch8DCu8HpZyeoHoD+SdH6L+qErcob6AQC1PQGZvWHgdHW/eo+km0cKyxLPA0+8Bng9ru6bTxugcQhwel1hndxU9ajU1b/Vdfw7A0+9pz9KJQTQ7RP9aURN30tTdPrR2HlmqKPy74LLbv3Q5MAcIHpWybliZiQRorjwteZKS0uDi4sLUlNT4ezsXO7rKBQK7NixA3369IFcLq/AFlYd7KN1YB+tg9X2USdZWaFQIHbF22gev0V/lKgsIy4Bweo/1tqE6yLP2/wfkJsJXNheOJLk3gRIvgLtKjXNRo9VigR6q+ikNuoy3XbKbNVfNVOFQGEftXXsCurk6lxLVjiVBQA29uqv+Tn6r6fKL3xuW1v9NS9D/7z8HIiC1lZ08FOWv98cASIioqqtyCiRRKigDJ4Eme4fzv0z9QOiUqbStAnXq/sWn4Bd0khS8MfqrwfmFAZDrQaqg4bzWwuDCv/O6pEfoVKPCjV7DlDkALH7AE0YULcpcP+itivCoQ7yc7Nho8pRBwkmKzKeoRuMaOgGPtrTlEXq5BrWURWpoxv4FPd6eUWH6grPkwAQEhkkFhj50WAARERE1coln5cR2KUPZLqFRafSNAFRSQnXus/jok2bNjJluq2kwMm7lfp57N7Cstqe6gCo4LmqwzuIvXJZPcqlqdOwizp40zzv8pE6qDo4vyD5WwH4PQXcOlL4/KnRAARwZElhkNZplPr1j/5QWFa/A3D7H5067xbUWVp8nY7vqOsc+7GwrF57dV6V5nn7Eeo6x5cXlvm0BeJPQSWRQSoKAlULBUEMgIiIyPqYknCtGyTprl4qbSRJKjO8dmmKC5yMjEBpk6CDJ0H27GTTRqnKOpJVlvMquI7Kvwv+p0lk19SxQBDEAIiIiGqGokGR7vPi/gAbG0kqOt2m+VrWwMmUEaiKqmNMZb6+Th1pXDSa5NWFqs9PkMl0crcqOQhiAERERFQcYyNJppSZGjgZGYFSBk/C5SuX0UQoAZXxOqZcp9QgzdTzKriO8u+ZkFwuyHnSvD9Fc4wqAQMgIiKiimZq4KShEyipFApcTt+BxsF9INNdzWfKCElJdUx8fXPXUXWZgEvpOxBYluuagbT0KkRERETWhQEQERER1ThVIgBavHgxGjZsCHt7e3Tq1AnHjh0rtu6qVasgkUj0Hvb29np1hBCYMmUKfHx84ODggJCQEFy5cqWYKxIREVFNY/EAaNOmTRg/fjymTp2KkydPonXr1ggLC8O9e/eKPcfZ2Rnx8fHax40bN/SOz549G99//z2WLl2Ko0ePolatWggLC0NOjpGNm0iPUiUQczUZ20/fQczVZChV3CiciIisj8WToOfNm4eRI0di+PDhAIClS5fir7/+wooVKzBp0iSj50gkEnh7exs9JoTAggUL8Pnnn+PFF18EAKxZswZeXl7Ytm0bBg4caJ6OWIFd5+IR/r//EJ9aGCj6uNhjat8W6PW4jwVbRkREVLEsGgDl5eXhxIkTmDy5MDNdKpUiJCQEMTExxZ6XkZEBf39/qFQqtGvXDjNmzEDLli0BAHFxcUhISEBISIi2vouLCzp16oSYmBijAVBubi5ycwu3/k5LSwOgvq+OQlH+e71ozn2Ua1SW3ecT8f7Gf4tupI6E1ByM+uUkFg5sjbCWXgbnVac+lhf7aB3YR+vAPlZ/5uxfWa5p0QAoKSkJSqUSXl76f1i9vLxw8eJFo+c0bdoUK1asQKtWrZCamoo5c+agc+fOOH/+POrXr4+EhATtNYpeU3OsqJkzZyI8PNygfM+ePXB0dCxP1/Ts3bv3ka9hTioBhJ+UFQQ/+neeEQX//XzLaSiuKyEt5sY0luyjSgBX0yRIUwDOciDQWRTbzkdR1T/HisA+Wgf20TpYex/N0b+srCyT61p8CqysgoKCEBQUpH3euXNnNG/eHD/++CO+/PLLcl1z8uTJGD9+vPZ5Wloa/Pz80LNnz0e+G/zevXsRGhpape/MfDTuAVKOHC+hhgQpeUC8S3O0b1AHtexkqGVng1q2NrCVqhD5d4TF+rj7fCJm7riIhLTCETxvZzt83qeZ0RGr8qgun+OjYB+tA/toHay9j+bsn2YGxxQWDYA8PDwgk8mQmJioV56YmFhsjk9Rcrkcbdu2RWxsLABoz0tMTISPT2HeSmJiItq0aWP0GnZ2drCzszN67Yr4cCrqOuaSnGXkjsFGzN5tfCWdjUQGp38Pora9OiiqbWeDWnbqr462Mu336q8FwVMxZbVsbSAzcfhm17l4o9N2iWm5eH/jv/hhcLsKzV2q6p9jRWAfrQP7aB2svY/m6F9ZrmfRAMjW1hZPPvkkIiIi0K9fPwCASqVCREQExowZY9I1lEolzp49iz59+gAAAgIC4O3tjYiICG3Ak5aWhqNHj2LUqFHm6Ea15+lkX3olAH51HCAAZOUpkZGbj7x8FQAgX0jwMEuBh1kVM59rL5dqg6PCgEo/kHKwlWH14esGwQ+gnraTAAj/338IbeFtckBV2ZQqgWNxD3AvPQeeTvboGOBWZdtKRGRtLD4FNn78eAwdOhTt27dHx44dsWDBAmRmZmpXhb3xxhuoV68eZs6cCQCYPn06nnrqKTRu3BgpKSn49ttvcePGDbz11lsA1CvExo0bh6+++gqPPfYYAgIC8MUXX8DX11cbZJG+jgFu8HGxR0JqjtGAQgLA28UekR931/sDnZevQmpmDv7cvRcdO3dBjlKCzNx8ZObmI6Pga2aeUqes4Ps8neO5Su33+QVL7nMUKuQo8pCUkVfuPgkA8ak56DRjH3xcHODqKEcdR1vUcZTD1dEWbrVsdcoKvq9li1q2Mkgk5g9CuOKOiMiyLB4ADRgwAPfv38eUKVOQkJCANm3aYNeuXdok5ps3b0IqLdyu6OHDhxg5ciQSEhJQp04dPPnkkzh8+DBatGihrTNx4kRkZmbi7bffRkpKCp555hns2rXLYMNEUpNJJZjatwVG/XISEkAvCNKEAlP7tjAYnbC1kcLVUQ43O6CJl9MjD2Xm5iuRWRAkZegFUoVlWXnqQOrcnVQcjE0q9ZpJGWULpGxlUrg4ylFHJzhycZAh+a4Udw9eh7uTvUEg5eIgL9PIza5z8Rj1y8liV9xV9NQdEREZsngABABjxowpdsorMjJS7/n8+fMxf/78Eq8nkUgwffp0TJ8+vaKaaPV6Pe6DHwa3MxiV8K7EUQk7GxnsbGRwq2Vbat2Yq8kmBUDTX2yJ+nUc8CBTgZSsPDzMysPDrILvMxUFz9Vlefkq5ClVuJ+ei/vpuUWuJMW+u5eNvoZEAjjby7VBkSZ40n5fy1YbNDnZyzFl+/lqPXVHRGQNqkQARFVDr8d9ENrCu1rkpZg6bfd6J3+T2i+EQLZCqc5lysxDSpY6OErJysP99Byc/u8KXD3rITUnvyCQUh9Pz8mHEEBqtgKp2Qog2fQlmEbbAfXU3fcRV9A50B11nexQ18kOte1sKmVqrjTMWyIia8EAiPTIpBIEBbpbuhmlKu+0XXEkEgkcbW3gaGuDeq4OescUCgV2ZF9Cnz5PGEzzKZQqpGhGlHSCJs33DzN1RpyyFEhMzUZ6rrLU9nwXcQXfRRSuurOzkWqDIY/a6q91a9vBo+BrXZ2vDrYyk/pcVsxbIiJrwgCIqq2qMG0nlxUGJqaIuZqMQcuOlFqvqVdt5OarkJSRh4zcfOTmq3D7YTZuP8wu9dzadjYFgZJtYaCkCZJ0AiiP2nawtTHtdoDMWyIia8MAiKq16jRtB5g+dbdjbLC2D1l5+UhKz8P9DHVu0v2MXCQVfNXkKyUVfJ+br0JGQcJ4XFJmqe1xcZCrg6FacuSlSXEKF+Hl4lgYPDnZwc3RFtP++I95S0RkVRgAUbVXXabtgPJN3Tna2qCBuw0auJd8WxYhBNJz89XBkZFAKSkjTy9gylcJbe6SehtRKU7G3CxznzR5S7vPJyCsJYMgIqoeGAARVTJzTd1JJBI428vhbC9Ho7q1S6yrKgh+NEFSfEoWDvxzGnX9ApGcpdALmJIyiq6IM+69dSchk0pQt7YdvFzs4e1sBx8XB3g528PbxU791dke3i72cLSt3H96lCqBo3EPcCJJAve4Bwhq7MlAjaiGYwBEZAGWnrqTSiXq5fm1bNHEywkKhQI2d06hT1gTg0TvQ7FJeP3no6VeUwJ1oJGQloOEtBz8W0JdJ3sb+LjY6wVFRb93r2ULaQW8H/rJ2zKsuXKcydtExACIyFKqy9TdU43cTdspfEI3PMxSqAOg1BwkFgRCiak52qAoITUHWXlKpOfkIz0nA5cTM4p9XblMAk8ndUDk7WyvN5Lk4+IAb2d7eDrbwV5e/Ko3Jm8TUXEYABFRiUzNW7KTy+DtIoO3iz3gZ/xamjwlbVCkEyglpOYiMS0H8ak5SM7MhUIpcCclG3dSSl75VsdRXhAcFQZKPi72qOtkh8+3nWPyNhEZxQCIiEpVUXlLunlKj3k5FVtPoVThXnpuYYCkEyjF65Tl5qu0N+K9mJBepj5pkrd/O3ELvZ/wgbO99d51m4gMMQAiIpNUZt6SXCZFPVcHg00pdQmhTuTWG0lKzUVCWjYSUnNwKTEDd0sZPQKAT34/i09+P4vadjbwdVVPr/m6OsDXxR6+rg7wcbVHPVcHeLvYw87GPJtMGsNdt4nMiwEQEZmsKuUtSSQSuBbcc62Zt7PBcVM3naxlJ0NmrhIZufm4nFhyXpJHbTv4utrD16UwMFIHTOpgqW5tOzMkbqsxcZuoYjEAIiKrZOqmkwc/eRa5+UrcTclBfGo27qZk425KDu6mZCM+Vf31bmo2chQqJGWotwU4czvV6GvKZRJ4OdsXGUFyQD3NyJKLA5wdSr6vGxO3iSoHAyAiskpl2XTS0dYGjT1ro7Gn8f2ThBB4mKUoCI50A6OCQCklGwlpOVAoRam3LKllK4OPa5FpNhf1aJKnsz2m/XGeidtElYABEBFZrYpM3narZQu3WrZ4vJ6L0Tr5BYnbmsAoviBY0gZJqTl4kJmHzDwlYu9lIPZe8VNtxdEkbh+LS0ZQoEeZzyeiQgyAiMiqaZK3Y2LvYc+Bo+jZpZNZdoK2kUnVozolJG5n5ykLptlycLdgui1e5/ubD7KgUBob/9E3ZPkxNHBzRL066kRx34KEcS8nOZJz1Kvo5FzURlQiBkBEZPVkUgk6Bbgh+YJAJwuupnKwlaFR3drF3qok5moSBi0rfdftfJXAtaRMXDN6w1sbfHV6H7yc1dNq9eoUBkiagKmeqwNq2Znnn3+uXqPqggEQEVEV0THAtF23173VCQlpObjzUL1R5J2H6kTt2w+ycfthJpRCgvhU9Z5Jx288NPparo5yvdGj+rqjSXUc4F7LtsRkbWO4eo2qEwZARERVhKmJ28WNIikUCvz51w50Cu6BxAxFYXBUsKP27YKAKT0nHylZCqRkKXD+bprRttjZSA1GjXx1nnu72EMuk2rrc/UaVTcMgIiIqpBHTdyWSoC6TnbwdauNtg3qGK2TlqNe0aYdQdL9/mE27qXnIjdfVcI0m/p1NNNsvq72iLh4j6vXqFphAEREVMWYe9dtZ3s5nL3lRjeQBIDcfCUSUtVTbLcLVrNpAiTNPkl5SpV2mg03Sn49zeq1qX+cwzONPVDPVZ3AXcdRXuZpNqKKwgCIiKgKsuSu23Y2Mvi714K/ey2jx1UqgaSMXG1wtOd8Iv74926p1/3lyE38cuSm9rmjrcwgQVuTi1SvjgM8newrZcSIids1EwMgIiIqE6lUAk9ne3g626Ndgzpwr2VnUgD0VIAbsvNVuPMwG0kZucgqZU8kG6lEe8sRzaiRt5MtbqdK0DI5C34etR/5/mxM3K65GAAREdEjMfW2I+tGPqUdWclRKLXJ2br5R7cLviak5SBfJXDrQTZuPcgG8EDnijIs+e8gAMDTyU6bnF1fN2m74KuTffEbIjFxu2ZjAERERI+kLLcd0bCXl7wnkmZnbd0A6fbDbNx+kInLd5KQmi9DjkJd5156Lk7fSjF6HWd7G9Sr42gwvebtbI8p23nbkZqMARARET2yirrtiIbuztodGhaWKxQK7NixA71790R6njAIkHSfp2YrkJaTj7T4NFyIN77cvziaxO3DsUno0qRumc6l6oEBEBERVQhzr17TJZFI4F7bFu617dCqvqvROhm5+QXBUJbe9NqdlGxcvZ+BtOz8Ul9nyIpj8HK209s0suhXZwcbrmarhhgAERFRhbHk6rWiatvZoKm3E5p6Oxkci7majEHLjph0ncS0XCSm5eLkzRSjx2vZyrS3HNGuanPVPLeHl7P+ppEVhavXHg0DICIiqnFMTdze+t7TSEzLKUzY1tkL6W5KNpIz85CZp8TlxAxcTjS+mk1/00hNkGSvFzQ5l5CsbQxXrz06BkBERFTjmJq47e1iD28Xe7T2czV6new8Je6maoIizRSbOji6m5qNeINNI43fm83JzkYbEHk72yItQQLlmXg0cK8NX1cHeDrZwaZgFImr1yoGAyAiIqqRKiJx28FWhsC6tRFYzGo2zaaRdwpGje6kZBV8LQyaHmYpkJ6bj4sJ6biYkF5wpgx/3jyrvY5MKoG3sz18Xexx9m4qV69VAAZARERUY5k7cVt308i2DYzXyczNR3xq4cjRzeQMHD9/FZLa7ohPy0F8inpPJM0UXEk0q9feWvUPWvm5wtfVHj4uDvBxsYePqwNq2/HPvgbfCSIiqtEsnbhdy84GjT2d0NhTnaytUCiwI+8K+vTpALlcDqVK4H7Bnkh/nL6D1TGl3HwNwP7L97H/8n2Dcid7G3Uw5OKgDY68Xezh6+IAH1d7+LjYw9HWfKGBUiVwNO4BTiRJ4B73AEGNPS02UsUAiIiIqAqTSSXaXKS8fJVJAdBrT9aHjUyizj1KycHd1Gyk5+QXPIpP2AYAFwc5fFzs1flILuppN91RJB8Xe9jLy34LEv3EbRnWXDlu0cRtBkBERETVhKmr12a90spgZCUjNx8JqepcpPjUbL3gKKEgSTsjNx+p2QqkZit08pEM1XGUG44i6Uy3ebvY692nrSombleJAGjx4sX49ttvkZCQgNatW2PhwoXo2LGj0brLli3DmjVrcO7cOQDAk08+iRkzZujVHzZsGFavXq13XlhYGHbt2mW+ThAREZlZeW47olG7yFSbMWk5CsTrBUjZ2hVsmlVt2QolHmYp8DBLgf9K2GHbo7ateuTK2R6HryZXucRtiwdAmzZtwvjx47F06VJ06tQJCxYsQFhYGC5dugRPT0+D+pGRkRg0aBA6d+4Me3t7fPPNN+jZsyfOnz+PevXqaev16tULK1eu1D63s7OrlP4QERGZU0XfdkSXs70czt5yo5tHAoAQAmnZ+dpRI01QpDuKdDclG7n5KiRl5CEpIw/n7pR8GxJN4vaxuAeVmotl8QBo3rx5GDlyJIYPHw4AWLp0Kf766y+sWLECkyZNMqi/bt06vec///wzfv/9d0REROCNN97QltvZ2cHb29u8jSciIrKAyrztiC6JRAIXRzlcHOVo7uNstI4QAilZCm1wtPu/BGw+frvUa99Lzym1TkWq+L25yyAvLw8nTpxASEiItkwqlSIkJAQxMTEmXSMrKwsKhQJubm565ZGRkfD09ETTpk0xatQoJCcnV2jbiYiILEmzeu3FNvUQFOheZfb9kUgkqFPLFi19XRDSwgsvt61v0nmeTvZmbpk+i44AJSUlQalUwsvLS6/cy8sLFy9eNOkan3zyCXx9ffWCqF69euHll19GQEAArl69ik8//RS9e/dGTEwMZDLDzPXc3Fzk5uZqn6elqYfrFAoFFApFebqmPV/3qzViH60D+2gd2EfrYG19bFvfCd7OdkhMyy0hcdsObes7PXKfy3K+RAhhrD2V4u7du6hXrx4OHz6MoKAgbfnEiRMRFRWFo0ePlnj+rFmzMHv2bERGRqJVq1bF1rt27RoCAwOxb98+9OjRw+D4tGnTEB4eblC+fv16ODo6lqFHREREVNS/yRKsuKyZdNIdqVKHIG82UaG1+6OHI1lZWfi///s/pKamwtnZ+BSdhkVHgDw8PCCTyZCYmKhXnpiYWGr+zpw5czBr1izs27evxOAHABo1agQPDw/ExsYaDYAmT56M8ePHa5+npaXBz88PPXv2LPUNLIlCocDevXsRGhoKubxsN7qrLthH68A+Wgf20TpYYx/7AGh3PhFf7biIhLTCGRcfF3t81rsZwlp6FX9yGWhmcExh0QDI1tYWTz75JCIiItCvXz8AgEqlQkREBMaMGVPsebNnz8bXX3+N3bt3o3379qW+zu3bt5GcnAwfH+OZ8XZ2dkZXicnl8gr54auo61Rl7KN1YB+tA/toHaytj8+3qY/ereohJvYe9hw4ip5dOlX4TtBleb8smgQNAOPHj8eyZcuwevVqXLhwAaNGjUJmZqZ2Vdgbb7yByZMna+t/8803+OKLL7BixQo0bNgQCQkJSEhIQEaGelfLjIwMfPzxxzhy5AiuX7+OiIgIvPjii2jcuDHCwsIs0kciIiJSJ253CnDDkx4CnSph1VpJLL4MfsCAAbh//z6mTJmChIQEtGnTBrt27dImRt+8eRNSaWGc9sMPPyAvLw+vvvqq3nWmTp2KadOmQSaT4cyZM1i9ejVSUlLg6+uLnj174ssvv+ReQERERASgCgRAADBmzJhip7wiIyP1nl+/fr3Eazk4OGD37t0V1DIiIiKyRhafAiMiIiKqbAyAiIiIqMZhAEREREQ1DgMgIiIiqnEYABEREVGNwwCIiIiIahwGQERERFTjVIl9gKoazf1hy3JPEWMUCgWysrKQlpZmVduZ62IfrQP7aB3YR+tg7X00Z/80f7dNuc87AyAj0tPTAQB+fn4WbgkRERGVVXp6OlxcXEqsIxGmhEk1jEqlwt27d+Hk5ASJpPz3KdHcVf7WrVuPdFf5qox9tA7so3VgH62DtffRnP0TQiA9PR2+vr56t9EyhiNARkilUtSvX7/Crufs7GyVP8S62EfrwD5aB/bROlh7H83Vv9JGfjSYBE1EREQ1DgMgIiIiqnEYAJmRnZ0dpk6dCjs7O0s3xWzYR+vAPloH9tE6WHsfq0r/mARNRERENQ5HgIiIiKjGYQBERERENQ4DICIiIqpxGAARERFRjcMAqIwWL16Mhg0bwt7eHp06dcKxY8dKrL9582Y0a9YM9vb2eOKJJ7Bjxw6940IITJkyBT4+PnBwcEBISAiuXLlizi6Uqix9XLZsGbp06YI6deqgTp06CAkJMag/bNgwSCQSvUevXr3M3Y1ilaV/q1atMmi7vb29Xp3q/hl269bNoI8SiQTPPfectk5V+wyjo6PRt29f+Pr6QiKRYNu2baWeExkZiXbt2sHOzg6NGzfGqlWrDOqU9ffbnMraxy1btiA0NBR169aFs7MzgoKCsHv3br0606ZNM/gcmzVrZsZelKysfYyMjDT6s5qQkKBXrzp/jsZ+1yQSCVq2bKmtU5U+x5kzZ6JDhw5wcnKCp6cn+vXrh0uXLpV6XlX428gAqAw2bdqE8ePHY+rUqTh58iRat26NsLAw3Lt3z2j9w4cPY9CgQRgxYgROnTqFfv36oV+/fjh37py2zuzZs/H9999j6dKlOHr0KGrVqoWwsDDk5ORUVrf0lLWPkZGRGDRoEPbv34+YmBj4+fmhZ8+euHPnjl69Xr16IT4+XvvYsGFDZXTHQFn7B6h3K9Vt+40bN/SOV/fPcMuWLXr9O3fuHGQyGV577TW9elXlMwSAzMxMtG7dGosXLzapflxcHJ577jl0794dp0+fxrhx4/DWW2/pBQjl+dkwp7L2MTo6GqGhodixYwdOnDiB7t27o2/fvjh16pRevZYtW+p9jgcPHjRH801S1j5qXLp0Sa8Pnp6e2mPV/XP87rvv9Pp269YtuLm5Gfw+VpXPMSoqCqNHj8aRI0ewd+9eKBQK9OzZE5mZmcWeU2X+NgoyWceOHcXo0aO1z5VKpfD19RUzZ840Wr9///7iueee0yvr1KmTeOedd4QQQqhUKuHt7S2+/fZb7fGUlBRhZ2cnNmzYYIYelK6sfSwqPz9fODk5idWrV2vLhg4dKl588cWKbmq5lLV/K1euFC4uLsVezxo/w/nz5wsnJyeRkZGhLatKn2FRAMTWrVtLrDNx4kTRsmVLvbIBAwaIsLAw7fNHfd/MyZQ+GtOiRQsRHh6ufT516lTRunXrimtYBTKlj/v37xcAxMOHD4utY22f49atW4VEIhHXr1/XllXlz/HevXsCgIiKiiq2TlX528gRIBPl5eXhxIkTCAkJ0ZZJpVKEhIQgJibG6DkxMTF69QEgLCxMWz8uLg4JCQl6dVxcXNCpU6dir2lO5eljUVlZWVAoFHBzc9Mrj4yMhKenJ5o2bYpRo0YhOTm5QttuivL2LyMjA/7+/vDz88OLL76I8+fPa49Z42e4fPlyDBw4ELVq1dIrrwqfYXmV9rtYEe9bVaNSqZCenm7wu3jlyhX4+vqiUaNGeP3113Hz5k0LtbD82rRpAx8fH4SGhuLQoUPacmv8HJcvX46QkBD4+/vrlVfVzzE1NRUADH7udFWVv40MgEyUlJQEpVIJLy8vvXIvLy+D+WeNhISEEutrvpblmuZUnj4W9cknn8DX11fvB7dXr15Ys2YNIiIi8M033yAqKgq9e/eGUqms0PaXpjz9a9q0KVasWIHt27fjl19+gUqlQufOnXH79m0A1vcZHjt2DOfOncNbb72lV15VPsPyKu53MS0tDdnZ2RXys1/VzJkzBxkZGejfv7+2rFOnTli1ahV27dqFH374AXFxcejSpQvS09Mt2FLT+fj4YOnSpfj999/x+++/w8/PD926dcPJkycBVMy/YVXJ3bt3sXPnToPfx6r6OapUKowbNw5PP/00Hn/88WLrVZW/jbwbPFWYWbNmYePGjYiMjNRLFB44cKD2+yeeeAKtWrVCYGAgIiMj0aNHD0s01WRBQUEICgrSPu/cuTOaN2+OH3/8EV9++aUFW2Yey5cvxxNPPIGOHTvqlVfnz7AmWr9+PcLDw7F9+3a9/JjevXtrv2/VqhU6deoEf39//PrrrxgxYoQlmlomTZs2RdOmTbXPO3fujKtXr2L+/PlYu3atBVtmHqtXr4arqyv69eunV15VP8fRo0fj3LlzFs0rKwuOAJnIw8MDMpkMiYmJeuWJiYnw9vY2eo63t3eJ9TVfy3JNcypPHzXmzJmDWbNmYc+ePWjVqlWJdRs1agQPDw/ExsY+cpvL4lH6pyGXy9G2bVtt263pM8zMzMTGjRtN+gfUUp9heRX3u+js7AwHB4cK+dmoKjZu3Ii33noLv/76q8E0Q1Gurq5o0qRJtfkcjenYsaO2/db0OQohsGLFCgwZMgS2trYl1q0Kn+OYMWPw559/Yv/+/ahfv36JdavK30YGQCaytbXFk08+iYiICG2ZSqVCRESE3giBrqCgIL36ALB3715t/YCAAHh7e+vVSUtLw9GjR4u9pjmVp4+AOlv/yy+/xK5du9C+fftSX+f27dtITk6Gj49PhbTbVOXtny6lUomzZ89q224tnyGgXpaam5uLwYMHl/o6lvoMy6u038WK+NmoCjZs2IDhw4djw4YNetsYFCcjIwNXr16tNp+jMadPn9a231o+R0C9uio2Ntak/yGx5OcohMCYMWOwdetW/P333wgICCj1nCrzt7HC0qlrgI0bNwo7OzuxatUq8d9//4m3335buLq6ioSEBCGEEEOGDBGTJk3S1j906JCwsbERc+bMERcuXBBTp04VcrlcnD17Vltn1qxZwtXVVWzfvl2cOXNGvPjiiyIgIEBkZ2dXev+EKHsfZ82aJWxtbcVvv/0m4uPjtY/09HQhhBDp6eliwoQJIiYmRsTFxYl9+/aJdu3aiccee0zk5ORU+f6Fh4eL3bt3i6tXr4oTJ06IgQMHCnt7e3H+/Hltner+GWo888wzYsCAAQblVe0z1LTp1KlT4tSpUwKAmDdvnjh16pS4ceOGEEKISZMmiSFDhmjrX7t2TTg6OoqPP/5YXLhwQSxevFjIZDKxa9cubZ3S3rfKVtY+rlu3TtjY2IjFixfr/S6mpKRo63z00UciMjJSxMXFiUOHDomQkBDh4eEh7t27V+n9E6LsfZw/f77Ytm2buHLlijh79qwYO3askEqlYt++fdo61f1z1Bg8eLDo1KmT0WtWpc9x1KhRwsXFRURGRur93GVlZWnrVNW/jQyAymjhwoWiQYMGwtbWVnTs2FEcOXJEe6xr165i6NChevV//fVX0aRJE2Fraytatmwp/vrrL73jKpVKfPHFF8LLy0vY2dmJHj16iEuXLlVGV4pVlj76+/sLAAaPqVOnCiGEyMrKEj179hR169YVcrlc+Pv7i5EjR1rsHyMhyta/cePGaet6eXmJPn36iJMnT+pdr7p/hkIIcfHiRQFA7Nmzx+BaVfEz1CyHLvrQ9Gvo0KGia9euBue0adNG2NraikaNGomVK1caXLek962ylbWPXbt2LbG+EOql/z4+PsLW1lbUq1dPDBgwQMTGxlZux3SUtY/ffPONCAwMFPb29sLNzU1069ZN/P333wbXrc6foxDqJd8ODg7ip59+MnrNqvQ5GusbAL3fr6r6t1FS0AEiIiKiGoM5QERERFTjMAAiIiKiGocBEBEREdU4DICIiIioxmEARERERDUOAyAiIiKqcRgAERERUY3DAIiIiIhqHAZAREREVOMwACKiaqdbt24YN26cwfeWVpXaQkQlYwBERFoxMTGQyWQm3Um8qtiyZQu+/PJLs76GRCIp8TFt2rRKa0tRu3fvLrV9e/bsqdQ2EVUHNpZuABFVHcuXL8f777+P5cuX4+7du/D19bV0k0rl5uZm9teIj4/Xfr9p0yZMmTIFly5d0pbVrl270tpSVHBwsF77Hn/8cbz33nt47733tGV169at9HYRVXUcASIiAEBGRgY2bdqEUaNG4bnnnsOqVav0jnfr1g0ffPABJk6cCDc3N3h7e2tHPspSR6VSYebMmQgICICDgwNat26N3377TXt8165deOaZZ+Dq6gp3d3c8//zzuHr1arHtLjrtZEob0tPT8frrr6NWrVrw8fHB/PnzS5y+8vb21j5cXFwgkUj0yjQBkLG2vP/++xg3bhzq1KkDLy8vLFu2DJmZmRg+fDicnJzQuHFj7Ny50+T3pygHBwdtO5RKJZKTk9GlSxe99slksmLPJ6qpGAAREQDg119/RbNmzdC0aVMMHjwYK1asgBBCr87q1atRq1YtHD16FLNnz8b06dOxd+/eMtWZOXMm1qxZg6VLl+L8+fP48MMPMXjwYERFRQEAMjMzMX78eBw/fhwRERGQSqV46aWXoFKpTO5LaW0YP348Dh06hD/++AN79+7FgQMHcPLkyfK8bSa1xcPDA8eOHcP777+PUaNG4bXXXkPnzp1x8uRJ9OzZE0OGDEFWVhaA0t+fkpw6dQoA0K5dO7P0hciqCCIiIUTnzp3FggULhBBCKBQK4eHhIfbv36893rVrV/HMM8/ondOhQwfxySefmFwnJydHODo6isOHD+vVGTFihBg0aJDRdt2/f18AEGfPntV7nbFjxxp8b0ob0tLShFwuF5s3b9YeT0lJEY6OjnrXKc7KlSuFi4uL0WOltSU/P1/UqlVLDBkyRFsWHx8vAIiYmJhyvT+6wsPDhZ+fX6n1iEgI5gARES5duoRjx45h69atAAAbGxsMGDAAy5cvR7du3bT1WrVqpXeej48P7t27p1dWUp3Y2FhkZWUhNDRUr05eXh7atm0LALhy5QqmTJmCo0ePIikpSTvyc/PmTTz++OMm9aekNly7dg0KhQIdO3bUHndxcUHTpk1NunZZ6bZFJpPB3d0dTzzxhLbMy8sLAHDv3j2T3p+SnDx5kqM/RCZiAEREWL58OfLz8/WSnoUQsLOzw6JFi+Di4gIAkMvleudJJBKDqamS6mRkZAAA/vrrL9SrV0+vnp2dHQCgb9++8Pf3x7Jly+Dr6wuVSoXHH38ceXl5JvfHlHZWFmNt0S2TSCQA1Lk/prw/JTl58iTeeuutR20yUY3AAIiohsvPz8eaNWswd+5c9OzZU+9Yv379sGHDBrz77rsV8lotWrSAnZ0dbt68ia5duxocT05OxqVLl7Bs2TJ06dIFAHDw4MEKeW2NRo0aQS6X459//kGDBg0AAKmpqbh8+TKCg4Mr9LXKqrT3pyRJSUm4desWR4CITMQAiKiG+/PPP/Hw4UOMGDFCO9Kj8corr2D58uUVFgA5OTlhwoQJ+PDDD6FSqfDMM88gNTUVhw4dgrOzM4YMGQJ3d3f89NNP8PHxwc2bNzFp0qQKeW3dNgwdOhQff/wx3Nzc4OnpialTp0IqlWpHYyyltPdn6NChxZ6rSeJmAERkGgZARDXc8uXLERISYhD8AOoAaPbs2Thz5kyFvd6XX36JunXrYubMmbh27RpcXV3Rrl07fPrpp5BKpdi4cSM++OADPP7442jatCm+//57vTykijBv3jy8++67eP755+Hs7IyJEyfi1q1bsLe3r9DXKY+S3p+SnDp1Cl5eXtVi7yaiqkAiRJF1rkRENUxmZibq1auHuXPnYsSIEZZuDhFVAo4AEVGNc+rUKVy8eBEdO3ZEamoqpk+fDgB48cUXLdwyIqosDICIqEaaM2cOLl26BFtbWzz55JM4cOAAPDw8LN0sIqoknAIjIiKiGoe3wiAiIqIahwEQERER1TgMgIiIiKjGYQBERERENQ4DICIiIqpxGAARERFRjcMAiIiIiGocBkBERERU4zAAIiIiohqHARARERHVOAyAiIiIqMb5f/CKuICgBPg2AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -192,17 +216,19 @@ ], "source": [ "# Plotting costs against annealing time\n", - "fqaoa_annealing_times = [ip * 0.1 for ip in fqaoa_ip_values]\n", - "qaoa_annealing_times = [ip * 0.01 for ip in qaoa_ip_values]\n", + "fqaoa_annealing_times = [ip * fqaoa_dt for ip in fqaoa_ip_values]\n", + "fqaoa_cost_list = [(fqaoa_cost_list[i]-min_x)/(max_x-min_x) for i in range(len(fqaoa_cost_list))]\n", + "qaoa_annealing_times = [ip * qaoa_dt for ip in qaoa_ip_values]\n", + "qaoa_cost_list = [(qaoa_cost_list[i]-min_x)/(max_x-min_x) for i in range(len(qaoa_cost_list))]\n", "\n", "# Plotting the results\n", + "fqaoa_cost_list\n", "plt.plot(fqaoa_annealing_times, fqaoa_cost_list, marker='o', label='FQAOA')\n", "plt.plot(qaoa_annealing_times, qaoa_cost_list, marker='x', label='QAOA')\n", "plt.xlabel('Annealing Time $T$')\n", "plt.ylabel('Cost')\n", "plt.title(r'Quantum Annealing Cost vs. Annealing Time')\n", - "plt.xlim(0, 1)\n", - "plt.grid(True)\n", + "plt.grid(True, which='both')\n", "plt.legend()\n", "plt.show()" ] @@ -212,11 +238,11 @@ "id": "94ed2180-28b8-4a47-937c-90bd6ab4eadd", "metadata": {}, "source": [ - "# FQAOA with Fourier Parametrization\n", + "## FQAOA with Fourier Parameterization\n", "\n", - "To appreciate the benefits of the Fourier parametrisation, let's compare the case $p=1$ using `StandardParams` with the case $q = 1, p=2$ using `FourierParams`. Here, we are optimising over the same total number of parameters, however the `FourierParams` ought to be capturing features of a more expressive circuit. \n", + "To appreciate the benefits of the Fourier parameterization, let's compare the case $p=1$ using `StandardParams` with the case $q = 1, p=2$ using `FourierParams`. Here, we are optimising over the same total number of parameters, however the `FourierParams` ought to be capturing features of a more expressive circuit. \n", "\n", - "Details of the Fourier parametrization are given in Ref [3] and in the Notebook `05 - QAOA circuit with advanced circuit parameterizations`." + "Details of the Fourier parameterization are given in Ref [[3]]((https://journals.aps.org/prx/pdf/10.1103/PhysRevX.10.021067)) and in the Notebook [`05 - QAOA circuit with advanced circuit parameterizations`](https://github.com/entropicalabs/openqaoa/blob/dev/examples/05_advanced_parameterization.ipynb)." ] }, { @@ -224,22 +250,22 @@ "id": "a147232a-3a4f-47d3-82a7-db8757bfa0ec", "metadata": {}, "source": [ - "### Fourier Parametrization" + "### Fourier Parameterization" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "b359fc8d-8f9b-4396-806e-d7f2c6e1ddc9", "metadata": {}, "outputs": [], "source": [ - "p_fourier = 2\n", + "p_fourier = 3\n", "q = 1\n", "\n", "fq_fourier = FQAOA()\n", "fq_fourier.set_circuit_properties(p=p_fourier, param_type='fourier', init_type='ramp', q=q)\n", - "fq_fourier.fermi_compile(problem = problem, n_fermions=budget)\n", + "fq_fourier.compile(problem = problem, n_fermions=budget)\n", "fq_fourier.optimize()" ] }, @@ -248,24 +274,22 @@ "id": "8ecbdf29-4cc3-42b4-827a-cdd6b4069666", "metadata": {}, "source": [ - "### Standard Parametrization" + "### Annealing Parameterization" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "ffb9aead-90b6-4430-b1ff-2045f2c017b4", "metadata": {}, "outputs": [], "source": [ - "p_list = [1, 2]\n", - "fq_std_list = []\n", - "for p in p_list:\n", - " fq_std = FQAOA()\n", - " fq_std.set_circuit_properties(p=p)\n", - " fq_std.fermi_compile(problem = problem, n_fermions=budget)\n", - " fq_std.optimize()\n", - " fq_std_list.append(fq_std)" + "p_annealing = 1\n", + "\n", + "fq_annealing = FQAOA()\n", + "fq_annealing.set_circuit_properties(p=p_annealing, param_type='annealing', init_type='ramp')\n", + "fq_annealing.compile(problem = problem, n_fermions=budget)\n", + "fq_annealing.optimize()" ] }, { @@ -273,20 +297,20 @@ "id": "66b12bb6-db7f-4caf-83b3-216151cb1d88", "metadata": {}, "source": [ - "## Performance Evaluation of FQAOA with Fourier Parametrization" + "## Performance Evaluation of FQAOA with Fourier Parameterization" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "id": "104e1c25-d674-4813-b706-f899b8fd23c6", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -294,16 +318,17 @@ } ], "source": [ - "fig = plt.figure(figsize=(10,7))\n", - "label_list = [f'Fourier params (p={p_fourier}, q={q}) optimization', \n", - " f'Stadard params (p={p_list[0]}) optimization',]\n", + "labels = [f'FQAOA with fourier params (p={p_fourier}, q={q})',\n", + " f'FQAOA with annealing params (p={p_annealing})',]\n", "\n", - "for i, fqaoa in enumerate([fq_fourier, fq_std_list[0]]):\n", - " yvalue = fqaoa.result.intermediate['cost']\n", - " plt.plot(yvalue,label=label_list[i],ls='-.')\n", + "for i, fqaoa in enumerate([fq_fourier, fq_annealing]):\n", + " cost = fqaoa.result.intermediate['cost']\n", + " cost = [(cost[i]-min_x)/(max_x-min_x) for i in range(len(cost))]\n", + " plt.plot(cost, label=labels[i], ls='--')\n", "\n", "plt.xlabel('Number of function evaluations')\n", "plt.ylabel('cost')\n", + "plt.grid(True)\n", "plt.legend()\n", "plt.title('Comparison of FQAOA performance between Fourier and Standard Parameterizations')\n", "plt.show()" @@ -315,9 +340,9 @@ "metadata": {}, "source": [ "# References\n", - "[1] T. Yoshioka, K. Sasada, Y. Nakano, and K. Fujii, [Phys. Rev. Research 5, 023071 (2023).](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071).\\\n", + "[1] T. Yoshioka, K. Sasada, Y. Nakano, and K. Fujii, [Phys. Rev. Research 5, 023071 (2023).](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071), [arXiv:2301.10756 [quant-ph]](https://arxiv.org/pdf/2301.10756).\\\n", "[2] E. Farhi, J. Goldston, S. Gutmann, and M. Sipser, [arXiv:quant-ph/0001106](https://arxiv.org/pdf/quant-ph/0001106).\\\n", - "[3] L. Zhou, S. Wang, S. Choi, H. Pichler, and M. D. Lukin, [Phys. Rev. X 10, 021067 (2020).](https://journals.aps.org/prx/pdf/10.1103/PhysRevX.10.021067)" + "[3] L. Zhou, S. Wang, S. Choi, H. Pichler, and M. D. Lukin, [Phys. Rev. X 10, 021067 (2020).](https://journals.aps.org/prx/pdf/10.1103/PhysRevX.10.021067), [arXiv:1812.01041v2 [quant-ph]](https://arxiv.org/pdf/1812.01041)." ] } ], diff --git a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py index 0f29d73f9..53c985c90 100644 --- a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py +++ b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py @@ -134,8 +134,8 @@ def get_analytical_fermi_orbitals( The number of fermions, which determines how many rows of the orbital matrix are considered in the computation. lattice : str - The type of lattice configuration. Currently, only 'cyclic' lattice configurations - are supported. + The type of lattice configuration. Only 'cyclic' lattice configurations + is supported. hopping : float The hopping parameter, which must be greater than 0. This value represents the amplitude of hopping between lattice sites. @@ -165,7 +165,7 @@ def get_analytical_fermi_orbitals( if n_fermions > n_qubits: raise ValueError(f"n_fermions ({n_fermions}) cannot be greater than n_qubits ({n_qubits}).") - if lattice not in 'cyclic': + if lattice not in ['cyclic']: raise ValueError("analytical solutions support only 'cyclic'") if hopping <= 0.0: raise ValueError("analytical solutions support hopping > 0") @@ -245,7 +245,7 @@ def get_fermi_orbitals( raise ValueError(f"n_fermions ({n_fermions}) cannot be greater than n_qubits ({n_qubits}).") if lattice not in ALLOWED_LATTICE: - raise ValueError(f"In FQAOA, lattice {lattice} is not recognised. Please use {ALLOWED_LATTICE}") + raise ValueError(f"In FQAOA, lattice {lattice} is not recognized. Please use {ALLOWED_LATTICE}") if hopping == 0.0: raise ValueError("In FQAOA, hopping = 0 is not recgnized. Please use hopping != 0") diff --git a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py index cd16a2f80..d33efe463 100644 --- a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py +++ b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py @@ -46,6 +46,14 @@ ALLOWED_INIT_TYPES = ["rand", "ramp", "custom"] ALLOWED_MIXERS = ["xy"] ALLOWED_LATTICE = ["cyclic", "chain"] +ALLOWED_LOCAL_SIMUALTORS = [ + "vectorized", + "pyquil.statevector_simulator", + 'qiskit.qasm_simulator', + 'qiskit.shot_simulator', + 'qiskit.statevector_simulator', +] +NOT_ALLOWED_LOCAL_SIMULATORS = ["analytical_simulator"] class FQAOA(Workflow): """ @@ -103,10 +111,11 @@ class FQAOA(Workflow): to use the function. >>> fqaoa = FQAOA() - >>> fqaoa.fermi_compile(problem, n_fermions) + >>> fqaoa.compile(problem, n_fermions) >>> fqaoa.optimize() - Where `problem` is an instance of portfolio optimization and `n_fermions` is a constraint value. + Where `problem` is an instance of `openqaoa.problems.problem.QUBO` + with hamming weight constant constraint, where `n_fermions` is a constraint value. If you want to use non-default parameters: @@ -123,7 +132,7 @@ class FQAOA(Workflow): >>> fqaoa_custom.set_device(device) >>> fqaoa_custom.set_backend_properties(n_shots=200) >>> fqaoa_custom.set_classical_optimizer(method='nelder-mead', maxiter=2) - >>> fqaoa_custom.fermi_compile(problem, n_fermions) + >>> fqaoa_custom.compile(problem, n_fermions) >>> fqaoa_custom.optimize() """ @@ -141,8 +150,8 @@ def __init__(self, device=DeviceLocal("vectorized")): self.backend_properties = FermiBackendProperties() # Exception handling in FQAOA - if device.device_name == 'analytical_simulator': - raise ValueError("FQAOA cannot be performed on the analytical simulator") + if device.device_name in NOT_ALLOWED_LOCAL_SIMULATORS: + raise ValueError(f"FQAOA does not support {NOT_ALLOWED_LOCAL_SIMULATORS}.") # change header algorithm to fqaoa self.header["algorithm"] = "fqaoa" @@ -158,8 +167,9 @@ def set_device(self, device: DeviceBase): Device to be used by the optimizer. """ - if device.device_name == 'analytical_simulator': - raise ValueError("FQAOA cannot be performed on the analytical simulator") + # Exception handling in FQAOA + if device.device_name in NOT_ALLOWED_LOCAL_SIMULATORS: + raise ValueError(f"FQAOA does not support {NOT_ALLOWED_LOCAL_SIMULATORS}.") # Call the parent class's set_device method to handle the rest super().set_device(device) @@ -189,8 +199,8 @@ def set_backend_properties(self, **kwargs): self.backend_properties = FermiBackendProperties(**kwargs) return None - @check_compiled + @check_compiled def set_circuit_properties(self, **kwargs): """ Specify the circuit properties to construct QAOA circuit @@ -255,22 +265,6 @@ def compile( hopping: float = 1.0, verbose: bool = False, routing_function: Optional[Callable] = None, - ): - """ - Prevents usage of the compile method. - """ - - raise NotImplementedError( - "In FQAOA, the compile(problem) method cannot be used; please use fermi_compile(problem, n_femions) instead." - ) - - def fermi_compile( - self, - problem: QUBO = None, - n_fermions: int = None, - hopping: float = 1.0, - verbose: bool = False, - routing_function: Optional[Callable] = None, ): """ Initialise the trainable parameters for FQAOA according to the specified @@ -297,7 +291,7 @@ def fermi_compile( # connect to the QPU specified self.device.check_connection() - # we compile the method of the parent class to genereate the id and + # we compile the method of the parent class to generate the id and # check the problem is a QUBO object and save it super().compile(problem=problem) @@ -350,8 +344,7 @@ def fermi_compile( lattice = self.circuit_properties.mixer_qubit_connectivity # fermion orbitals - if lattice == "cyclic" and hopping > 0.0: orbitals = get_analytical_fermi_orbitals(self.n_qubits, self.n_fermions, lattice, hopping) - else: orbitals = get_fermi_orbitals(self.n_qubits, self.n_fermions, lattice, hopping) + orbitals = get_fermi_orbitals(self.n_qubits, self.n_fermions, lattice, hopping) # initial statevector or circuit if self.device.device_name in 'vectorized': @@ -487,7 +480,7 @@ def evaluate_circuit( """ # before evaluating the circuit we check that the QAOA object has been compiled if self.compiled is False: - raise ValueError("Please compile the QAOA before optimizing it!") + raise ValueError("Please compile the FQAOA before optimizing it!") # Check the type of the input parameters and save them as a # QAOAVariationalBaseParams object at the variable `params_obj` @@ -654,7 +647,7 @@ def _fermi_initial_circuit(self, orbitals: np.array, gate_applicator: object) -> gate = X(gate_applicator, i) gate.apply_gate(initial_circuit) - # appply `givens rotation gate` + # apply `givens rotation gate` gtheta = get_givens_rotation_angle(orbitals) i = (self.n_qubits-self.n_fermions)*self.n_fermions for irow in range(self.n_fermions-1, -1, -1): @@ -712,21 +705,20 @@ def __init__(self, qubit_1: int, qubit_2: int, angle: float): @property def _decomposition_standard(self) -> List[Tuple]: - givens_rotation = [] - givens_rotation.append((RZ, [self.qubit_2, RotationAngle(lambda x: x, self.gate_label, np.pi / 2)])) - givens_rotation.append((RZ, [self.qubit_1, RotationAngle(lambda x: x, self.gate_label, np.pi / 2)])) - givens_rotation.append((RY, [self.qubit_1, RotationAngle(lambda x: x, self.gate_label, np.pi / 2)])) - givens_rotation.append((X, [self.qubit_1])) - givens_rotation.append((CX, [self.qubit_1, self.qubit_2])) - givens_rotation.append((RY, [self.qubit_2, RotationAngle(lambda x: x, self.gate_label, self.angle)])) - givens_rotation.append((RY, [self.qubit_1, RotationAngle(lambda x: x, self.gate_label, self.angle)])) - givens_rotation.append((CX, [self.qubit_1, self.qubit_2])) - givens_rotation.append((RY, [self.qubit_1, RotationAngle(lambda x: x, self.gate_label, np.pi / 2)])) - givens_rotation.append((X, [self.qubit_1])) - givens_rotation.append((RZ, [self.qubit_2, RotationAngle(lambda x: x, self.gate_label, -np.pi / 2)])) - givens_rotation.append((RZ, [self.qubit_1, RotationAngle(lambda x: x, self.gate_label, -np.pi / 2)])) - - return givens_rotation + return[ + (RZ, [self.qubit_2, RotationAngle(lambda x: x, self.gate_label, np.pi / 2)]), + (RZ, [self.qubit_1, RotationAngle(lambda x: x, self.gate_label, np.pi / 2)]), + (RY, [self.qubit_1, RotationAngle(lambda x: x, self.gate_label, np.pi / 2)]), + (X, [self.qubit_1]), + (CX, [self.qubit_1, self.qubit_2]), + (RY, [self.qubit_2, RotationAngle(lambda x: x, self.gate_label, self.angle)]), + (RY, [self.qubit_1, RotationAngle(lambda x: x, self.gate_label, self.angle)]), + (CX, [self.qubit_1, self.qubit_2]), + (RY, [self.qubit_1, RotationAngle(lambda x: x, self.gate_label, np.pi / 2)]), + (X, [self.qubit_1]), + (RZ, [self.qubit_2, RotationAngle(lambda x: x, self.gate_label, -np.pi / 2)]), + (RZ, [self.qubit_1, RotationAngle(lambda x: x, self.gate_label, -np.pi / 2)]), + ] class FermiBackendProperties(WorkflowProperties): """ @@ -765,7 +757,7 @@ class FermiBackendProperties(WorkflowProperties): rewiring: str Specify the rewiring strategy for compilation for Rigetti QPUs through QCS disable_qubit_rewiring: bool - enable/disbale qubit rewiring when accessing QPUs via the AWS `braket` + enable/disable qubit rewiring when accessing QPUs via the AWS `braket` """ def __init__( @@ -789,11 +781,11 @@ def __init__( disable_qubit_rewiring: Optional[bool] = None, ): if init_hadamard: - raise ValueError("In FQAOA, init_hadamard is not recognised.") + raise ValueError("In FQAOA, init_hadamard is not recognized.") if prepend_state is not None: - raise ValueError("In FQAOA, prepend_state is not recognised.") + raise ValueError("In FQAOA, prepend_state is not recognized.") if append_state is not None: - raise ValueError("In FQAOA, append_state is not recognised.") + raise ValueError("In FQAOA, append_state is not recognized.") self.init_hadamard = False self.prepend_state = None self.append_state = None @@ -848,9 +840,9 @@ def __init__( linear_ramp_time if linear_ramp_time is not None else 0.7 * self.p ) if mixer_hamiltonian.lower() not in ALLOWED_MIXERS: - raise ValueError(f"In FQAOA, mixer_hamiltonian {mixer_hamiltonian.lower()} is not recognised. Please use {ALLOWED_MIXERS}") + raise ValueError(f"In FQAOA, mixer_hamiltonian {mixer_hamiltonian.lower()} is not recognized.") if mixer_qubit_connectivity not in ALLOWED_LATTICE: - raise ValueError(f"In FQAOA, mixer_qubit_connectivity {mixer_qubit_connectivity} is not recognised. Please use {ALLOWED_LATTICE}") + raise ValueError(f"In FQAOA, mixer_qubit_connectivity {mixer_qubit_connectivity} is not recognized.") self.mixer_hamiltonian = mixer_hamiltonian self.mixer_qubit_connectivity = mixer_qubit_connectivity self.mixer_coeffs = mixer_coeffs @@ -864,7 +856,7 @@ def param_type(self): def param_type(self, value): if value not in ALLOWED_PARAM_TYPES: raise ValueError( - f"param_type {value} is not recognised. Please use {ALLOWED_PARAM_TYPES}" + f"param_type {value} is not recognized. Please use {ALLOWED_PARAM_TYPES}" ) self._param_type = value @@ -876,7 +868,7 @@ def init_type(self): def init_type(self, value): if value not in ALLOWED_INIT_TYPES: raise ValueError( - f"init_type {value} is not recognised. Please use {ALLOWED_INIT_TYPES}" + f"init_type {value} is not recognized. Please use {ALLOWED_INIT_TYPES}" ) self._init_type = value @@ -888,7 +880,7 @@ def mixer_hamiltonian(self): def mixer_hamiltonian(self, value): if value not in ALLOWED_MIXERS: raise ValueError( - f"mixer_hamiltonian {value} is not recognised. Please use {ALLOWED_MIXERS}" + f"mixer_hamiltonian {value} is not recognized. Please use {ALLOWED_MIXERS}" ) self._mixer_hamiltonian = value diff --git a/src/openqaoa-core/tests/test_fqaoa.py b/src/openqaoa-core/tests/test_fqaoa.py index 5e0b748f6..af72ce2e8 100644 --- a/src/openqaoa-core/tests/test_fqaoa.py +++ b/src/openqaoa-core/tests/test_fqaoa.py @@ -7,7 +7,6 @@ get_fermi_orbitals, get_givens_rotation_angle, get_statevector, - generate_random_portfolio_data, ) """ @@ -39,7 +38,7 @@ def setUp(self): def test_fermi_orbitals_equivalence_to_statevector(self): """ - Test that get_analytical_fermi_oribalts and get_fermi_orbitals are equivalent by outputting statevector. + Test that get_analytical_fermi_orbitals and get_fermi_orbitals are equivalent by outputting statevector. The test consists of generating analytical and numerical free fermi orbitals and checking that the respective state vectors are numerically consistent. @@ -49,23 +48,13 @@ def test_fermi_orbitals_equivalence_to_statevector(self): (5, 3, "cyclic", 1.0), (5, 2, "cyclic", 1.0) ]: - try: - orbitals1 = get_analytical_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) - except ValueError as e: - self.fail(f"Unexpected exception raised: {e}") - - try: - orbitals2 = get_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) - except ValueError as e: - self.fail(f"Unexpected exception raised: {e}") - - statevector = [] - for orbitals in [orbitals1, orbitals2]: - statevector.append(get_statevector(orbitals)) - # Check statevector[0] = e^(i*theta) * statevector[1]. - self.assertTrue(self.is_close_statevector(statevector), "Statevectors are not equivalent up to a global phase.") - - def test_gicvens_rotation_angle_length(self): + analytical_fermi_orbitals = get_analytical_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) + fermi_orbitals = get_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) + statevector = [get_statevector(analytical_fermi_orbitals), get_statevector(fermi_orbitals)] + self.assertTrue(is_close_statevector(statevector[0], statevector[1]), + "statevector[0] cannot be expressed as e^(i*theta) * statevector[1].") + + def test_givens_rotation_angle_length(self): """ Test with various valid inputs for get_givens_rotation_angle. @@ -79,13 +68,12 @@ def test_gicvens_rotation_angle_length(self): lattice = params["lattice"] hopping = params["hopping"] - if lattice == "cyclic" and hopping > 0.0: orbitals = get_analytical_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) - else: orbitals = get_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) + if lattice == "cyclic" and hopping > 0.0: + orbitals = get_analytical_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) + else: + orbitals = get_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) - try: - gtheta = get_givens_rotation_angle(orbitals) - except ValueError as e: - self.fail(f"Unexpected exception raised: {e}") + gtheta = get_givens_rotation_angle(orbitals) # Check the diagonal matrix self.assertTrue(self.is_left_aligned_diagonal_matrix(orbitals), "orbitals are not diagonalized") @@ -108,8 +96,10 @@ def test_givens_rotation_to_statevector(self): lattice = params["lattice"] hopping = params["hopping"] - if lattice == "cyclic" and hopping > 0.0: orbitals0 = get_analytical_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) - else: orbitals0 = get_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) + if lattice == "cyclic" and hopping > 0.0: + orbitals0 = get_analytical_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) + else: + orbitals0 = get_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) orbitals1 = copy.deepcopy(orbitals0) gtheta = get_givens_rotation_angle(orbitals1) @@ -129,16 +119,9 @@ def test_givens_rotation_to_statevector(self): temp = matrix[ik][icol - 1] matrix[ik][icol - 1] = temp * np.cos(-angle) - matrix[ik][icol] * np.sin(-angle) matrix[ik][icol] = temp * np.sin(-angle) + matrix[ik][icol] * np.cos(-angle) - statevector = [] - for i, orbitals in enumerate([orbitals0, matrix]): - - try: - statevector.append(get_statevector(orbitals)) - except ValueError as e: - self.fail(f"Unexpected exception raised: {e}") - - # Check statevector[0] = e^(i*theta) * statevector[1]. - self.assertTrue(self.is_close_statevector(statevector), "statevectors are incorrect") + statevector = [get_statevector(orbitals0), get_statevector(matrix)] + self.assertTrue(is_close_statevector(statevector[0], statevector[1]), + "statevector[0] cannot be expressed as e^(i*theta) * statevector[1].") # exception handling def test_fermi_analytical_orbital_invalid_input(self): @@ -148,6 +131,7 @@ def test_fermi_analytical_orbital_invalid_input(self): (3, 5, "cyclic", 1.0), # n_fermions > n_qubits (5, 3, "cyclic", -1.0), # hopping < 0.0 (5, 3, "cyclic", 0.0), # hopping = 0.0 + (5, 3, "cyc", 1.0), # lattice = "cyc" ]: with self.assertRaises(ValueError): get_analytical_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) @@ -164,70 +148,6 @@ def test_fermi_orbital_invalid_input(self): with self.assertRaises(ValueError): get_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) - def test_generate_portfolio_data_shapes(self): - """Test that the function returns outputs with correct shapes.""" - num_assets, num_days = 10, 15 - # Generate data with the seed - seed = 1 - mu, sigma, hist_exp = generate_random_portfolio_data(num_assets, num_days, seed) - - # Check the shape - self.assertEqual(len(mu), num_assets) - self.assertEqual(len(sigma), num_assets) - self.assertEqual(len(sigma[0]), num_assets) - self.assertEqual(hist_exp.shape, (num_assets, num_days)) - - def test_generate_portfolio_data_without_seed(self): - """Test that setting a seed produces the same output.""" - num_assets, num_days = 10, 15 - # Generate data without the seed - mu1, sigma1, hist_exp1 = generate_random_portfolio_data(num_assets, num_days) - mu2, sigma2, hist_exp2 = generate_random_portfolio_data(num_assets, num_days) - - # Check that the two runs produce different results - self.assertNotEqual(mu1, mu2) - self.assertNotEqual(sigma1, sigma2) - self.assertFalse(np.array_equal(hist_exp1, hist_exp2)) - - @staticmethod - def is_close_statevector(statevector) -> bool: - """ - Checks if statevector[0] can be expressed as e^(i*theta) * statevector[1]. - """ - - # Threshold for considering a value to be zero - tolerance = 1e-10 - - # Check if statevector[0] is approximately zero where statevector[1] is approximately zero - zero_mask_1 = np.isclose(statevector[1], 0, atol=tolerance) - zero_mask_0 = np.isclose(statevector[0], 0, atol=tolerance) - - if np.all(zero_mask_1 == zero_mask_0): - # Create a mask to avoid division by zero - non_zero_mask = ~np.isclose(statevector[1], 0, atol=tolerance) - - # Compute the ratio with the mask applied - ratio = statevector[0][non_zero_mask] / statevector[1][non_zero_mask] - - # Verify if all ratios have the same phase angle - theta_calculated = np.angle(ratio) - theta_adjusted = (theta_calculated + np.pi) % (2 * np.pi) - np.pi - - # Check if the phase difference is consistent - consistent_phase = np.allclose(theta_adjusted, theta_adjusted[0]) - - if consistent_phase: - theta = theta_adjusted[0] - print(f"statevector[0] can be expressed as e^(i*theta) * statevector[1] with theta={theta}.") - return True - print("statevector[0] cannot be expressed as e^(i*theta) * statevector[1].") - print('theta_adjusted', theta_adjusted) - return False - print("It cannot be confirmed that statevector[0] is approximately zero when statevector[1] is approximately zero.") - for i in range(len(statevector[0])): - print(statevector[0][i], statevector[1][i]) - return False - @staticmethod def is_left_aligned_diagonal_matrix(matrix: np.ndarray) -> bool: """ @@ -235,9 +155,6 @@ def is_left_aligned_diagonal_matrix(matrix: np.ndarray) -> bool: and all other elements as 0. """ - np.set_printoptions(precision=3, suppress=True, linewidth=100) - print('fermi orbitals diagonalized by givens rotations') - rows, cols = matrix.shape for i in range(rows): for j in range(cols): @@ -249,5 +166,39 @@ def is_left_aligned_diagonal_matrix(matrix: np.ndarray) -> bool: return False return True +def is_close_statevector(statevector1, statevector2) -> bool: + """ + Checks if statevector1 can be expressed as e^(i*theta) * statevector2. + """ + + # Threshold for considering a value to be zero + tolerance = 1e-10 + + # Check if statevector1 is approximately zero where statevector2 is approximately zero + zero_mask_0 = np.isclose(statevector1, 0, atol=tolerance) + zero_mask_1 = np.isclose(statevector2, 0, atol=tolerance) + + if np.all(zero_mask_1 == zero_mask_0): + # Create a mask to avoid division by zero + non_zero_mask = ~np.isclose(statevector2, 0, atol=tolerance) + + # Compute the ratio with the mask applied + ratio = statevector1[non_zero_mask] / statevector2[non_zero_mask] + + # Verify if all ratios have the same phase angle + theta_calculated = np.angle(ratio) + theta_adjusted = (theta_calculated + np.pi) % (2 * np.pi) - np.pi + consistent_phase = np.allclose(theta_adjusted, theta_adjusted[0]) + + # Verify if all absolute values are same + absolute_ratio = np.abs(statevector1[non_zero_mask] / statevector2[non_zero_mask]) + consistent_magnitude = np.allclose(absolute_ratio, absolute_ratio[0]) + + if consistent_phase and consistent_magnitude: + return True + + return False + return False + if __name__ == '__main__': unittest.main() diff --git a/src/openqaoa-core/tests/test_workflows.py b/src/openqaoa-core/tests/test_workflows.py index 2c5576c4d..f9e2ce06f 100644 --- a/src/openqaoa-core/tests/test_workflows.py +++ b/src/openqaoa-core/tests/test_workflows.py @@ -26,7 +26,6 @@ from openqaoa.algorithms.fqaoa.fqaoa_utils import ( get_analytical_fermi_orbitals, get_statevector, - generate_random_portfolio_data, ) from openqaoa.backends import create_device, DeviceLocal from openqaoa.backends.cost_function import cost_function @@ -56,6 +55,7 @@ PARAMS_CLASSES_MAPPER, ) +from test_fqaoa import is_close_statevector def _compare_qaoa_results(dict_old, dict_new): for key in dict_old.keys(): @@ -115,7 +115,6 @@ def _test_keys_in_dict(obj, expected_keys): for item in obj: _test_keys_in_dict(item, expected_keys) - class TestingVanillaQAOA(unittest.TestCase): """ Unit test based testing of the QAOA workflow class @@ -345,7 +344,7 @@ def test_set_circuit_properties_qaoa_descriptor_mixer_xy(self): def test_set_circuit_properties_variate_params(self): """ - Ensure that the Varitional Parameter Object created based on the input string , param_type, is correct. + Ensure that the Variational Parameter Object created based on the input string , param_type, is correct. TODO: Check if q=None is the appropriate default. """ @@ -382,7 +381,7 @@ def test_set_circuit_properties_variate_params(self): def test_set_circuit_properties_change(self): """ - Ensure that once a property has beefn changed via set_circuit_properties. + Ensure that once a property has been changed via set_circuit_properties. The attribute has been appropriately updated. Updating all attributes at the same time. """ @@ -1134,7 +1133,7 @@ def test_qaoa_from_dict_and_load(self): nw.generators.fast_gnp_random_graph(n=6, p=0.6, seed=42) ).qubo - # run rqaoa with different devices, and save the objcets in a list + # run rqaoa with different devices, and save the objects in a list qaoas = [] for device in [ create_device(location="local", name="vectorized"), @@ -1406,28 +1405,24 @@ def test_qaoa_evaluate_circuit_shot(self): q.set_device(device) q.set_circuit_properties(p=3) - # try to evaluate the circuit before compiling - error = False - try: - q.evaluate_circuit() - except Exception: - error = True - assert ( - error - ), f"param_type={param_type}. `evaluate_circuit` should raise an error if the circuit is not compiled" + with self.assertRaises(ValueError) as cm: + q.evaluate_circuit([1, 2, 1, 2, 1, 2]) + self.assertIn( + "Please compile the QAOA before optimizing it!", + str(cm.exception), + ) # compile and evaluate the circuit, and check that the result is correct q.compile(problem) result = q.evaluate_circuit([1, 2, 1, 2, 1, 2]) - assert isinstance( - result["measurement_results"], dict - ), "When using a shot-based simulator, `evaluate_circuit` should return a dict of counts" - assert ( - abs(result["cost"]) >= 0 - ), "When using a shot-based simulator, `evaluate_circuit` should return a cost" - assert ( - abs(result["uncertainty"]) > 0 - ), "When using a shot-based simulator, `evaluate_circuit` should return an uncertainty" + self.assertTrue( + abs(result["cost"]) >= 0, + "When using a shot-based simulator, evaluate_circuit should return a cost" + ) + self.assertTrue( + abs(result["uncertainty"]) > 0, + "When using a shot-based simulator, evaluate_circuit should return an uncertainty" + ) cost = cost_function( result["measurement_results"], @@ -1440,12 +1435,14 @@ def test_qaoa_evaluate_circuit_shot(self): q.backend.cvar_alpha, ) uncertainty = np.sqrt(cost_sq - cost**2) - assert ( - np.round(cost, 12) == result["cost"] - ), "When using a shot-based simulator, `evaluate_circuit` not returning the correct cost" - assert ( - np.round(uncertainty, 12) == result["uncertainty"] - ), "When using a shot-based simulator, `evaluate_circuit` not returning the correct uncertainty" + self.assertTrue( + np.round(cost, 12) == result["cost"], + "When using a shot-based simulator, evaluate_circuit not returning the correct cost" + ) + self.assertTrue( + np.round(uncertainty, 12) == result["uncertainty"], + "When using a shot-based simulator, evaluate_circuit not returning the correct uncertainty" + ) def test_qaoa_evaluate_circuit_analytical_sim(self): # problem @@ -1736,7 +1733,7 @@ class TestingFQAOA(unittest.TestCase): Unit test based testing of the QAOA workflow class """ - def test_vanilla_qaoa_default_values(self): + def test_vanilla_fqaoa_default_values(self): fqaoa = FQAOA() assert fqaoa.circuit_properties.p == 1 assert fqaoa.circuit_properties.param_type == "standard" @@ -1747,16 +1744,15 @@ def test_vanilla_qaoa_default_values(self): assert fqaoa.device.device_name == "vectorized" def test_end_to_end_vectorized(self): - num_assets, budget = 5, 3 - mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) - po = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo + num_assets, budget = 4, 2 + po = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget).qubo fqaoa = FQAOA() fqaoa.set_classical_optimizer(optimization_progress=True) - fqaoa.fermi_compile(po, budget) + fqaoa.compile(po, budget) fqaoa.optimize() result = fqaoa.result.most_probable_states["solutions_bitstrings"][0] - assert "11010" == result + assert "1010" == result def test_set_device_local(self): """ " @@ -1783,18 +1779,17 @@ def test_compile_before_optimise(self): def test_cost_hamil(self): num_assets, budget = 5, 3 - mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) - qubo_problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo + problem = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget).qubo test_hamil = Hamiltonian.classical_hamiltonian( - terms=qubo_problem.terms, - coeffs=qubo_problem.weights, - constant=qubo_problem.constant, + terms=problem.terms, + coeffs=problem.weights, + constant=problem.constant, ) fqaoa = FQAOA() - fqaoa.fermi_compile(problem=qubo_problem, n_fermions=budget) + fqaoa.compile(problem=problem, n_fermions=budget) self.assertEqual(fqaoa.cost_hamil.expression, test_hamil.expression) self.assertEqual( @@ -1838,12 +1833,9 @@ def test_set_circuit_properties_annealing_time_linear_ramp_time(self): self.assertEqual(fqaoa.circuit_properties.annealing_time, 0.7 * 2) self.assertEqual(fqaoa.circuit_properties.linear_ramp_time, 0.7 * 2) - def test_set_circuit_properties_qaoa_descriptor_mixer_x(self): + def test_set_circuit_properties_fqaoa_descriptor_mixer_x(self): """ - Checks if the X mixer created by the X_mixer_hamiltonian method - and the automated methods in workflows do the same thing. - - For each qubit, there should be 1 RXGateMap per layer of p. + Checks if setting the incorrect mixer_hamiltonian 'x' raises a ValueError. """ nodes = 6 @@ -1853,10 +1845,10 @@ def test_set_circuit_properties_qaoa_descriptor_mixer_x(self): fqaoa = FQAOA() self.assertRaises( - ValueError, lambda: fqaoa.set_circuit_properties(param_type="wrong name") + ValueError, lambda: fqaoa.set_circuit_properties(mixer_hamiltonian="x") ) - def test_set_circuit_properties_qaoa_descriptor_mixer_xy(self): + def test_set_circuit_properties_fqaoa_descriptor_mixer_xy(self): """ Checks if the XY mixer created by the XY_mixer_hamiltonian method and the automated methods in workflows do the same thing. @@ -1866,8 +1858,7 @@ def test_set_circuit_properties_qaoa_descriptor_mixer_xy(self): """ num_assets, budget = 5, 3 - mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) - problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo + problem = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget).qubo qubit_connectivity_name = ["cyclic", "chain"] @@ -1879,7 +1870,7 @@ def test_set_circuit_properties_qaoa_descriptor_mixer_xy(self): p=2, ) - fqaoa.fermi_compile(problem, budget, hopping = -1.0) + fqaoa.compile(problem, budget, hopping = -1.0) self.assertEqual(type(fqaoa.qaoa_descriptor), QAOADescriptor) self.assertEqual(fqaoa.qaoa_descriptor.p, 2) @@ -1899,7 +1890,7 @@ def test_set_circuit_properties_qaoa_descriptor_mixer_xy(self): def test_set_circuit_properties_variate_params(self): """ - Ensure that the Varitional Parameter Object created based on the input string , param_type, is correct. + Ensure that the Variational Parameter Object created based on the input string , param_type, is correct. TODO: Check if q=None is the appropriate default. """ @@ -1922,44 +1913,25 @@ def test_set_circuit_properties_variate_params(self): ] num_assets, budget = 5, 3 - mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) - problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None) + problem = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget).qubo for i in range(len(object_types)): fqaoa = FQAOA() fqaoa.set_circuit_properties(param_type=param_type_names[i], q=1) - fqaoa.fermi_compile(problem=problem.qubo, n_fermions=budget) + fqaoa.compile(problem=problem, n_fermions=budget) self.assertEqual(type(fqaoa.variate_params), object_types[i]) def test_set_circuit_properties_change(self): """ - Ensure that once a property has beefn changed via set_circuit_properties. + Ensure that once a property has been changed via set_circuit_properties. The attribute has been appropriately updated. Updating all attributes at the same time. """ - # default_pairings = {'param_type': 'standard', - # 'init_type': 'ramp', - # 'qubit_register': [], - # 'p': 1, - # 'q': None, - # 'annealing_time': 0.7, - # 'linear_ramp_time': 0.7, - # 'variational_params_dict': {}, - # 'mixer_hamiltonian': 'x', - # 'mixer_qubit_connectivity': None, - # 'mixer_coeffs': None, - # 'seed': None} - fqaoa = FQAOA() - # TODO: Some weird error related to the initialisation of QAOA here - # for each_key, each_value in default_pairings.items(): - # print(each_key, getattr(fqaoa.circuit_properties, each_key), each_value) - # self.assertEqual(getattr(fqaoa.circuit_properties, each_key), each_value) - update_pairings = { "param_type": "fourier", "init_type": "rand", @@ -2023,7 +1995,7 @@ def test_set_backend_properties_change(self): } fqaoa.set_backend_properties(**update_pairings) - + for each_key, each_value in update_pairings.items(): self.assertEqual(getattr(fqaoa.backend_properties, each_key), each_value) @@ -2062,7 +2034,7 @@ def test_set_backend_init_append_state_change(self): append_state_rand = np.random.rand(2**2) with self.assertRaises(ValueError): fqaoa.set_backend_properties(append_state=append_state_rand) - + def test_set_backend_properties_check_backend_vectorized(self): """ Check if the backend returned by set_backend_properties is correct @@ -2071,12 +2043,11 @@ def test_set_backend_properties_check_backend_vectorized(self): """ num_assets, budget = 5, 3 - mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) - problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None) + problem = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget).qubo fqaoa = FQAOA() fqaoa.set_device(create_device(location="local", name="vectorized")) - fqaoa.fermi_compile(problem=problem.qubo, n_fermions=3) + fqaoa.compile(problem=problem, n_fermions=3) orbitals = get_analytical_fermi_orbitals(n_qubits=num_assets, n_fermions=budget, lattice="cyclic", hopping=1.0) initial_state = get_statevector(orbitals) @@ -2084,10 +2055,14 @@ def test_set_backend_properties_check_backend_vectorized(self): self.assertEqual(type(fqaoa.backend), QAOAvectorizedBackendSimulator) self.assertEqual(fqaoa.backend.init_hadamard, False) - self.assertTrue(np.array_equal(fqaoa.backend.prepend_state, initial_state)) + + statevector = [fqaoa.backend.prepend_state, initial_state] + is_close_statevector(statevector[0], statevector[1]) + self.assertTrue(is_close_statevector(statevector[0], statevector[1]), + f"statevector[0] cannot be expressed as e^(i*theta) * statevector[1].") + self.assertEqual(fqaoa.backend.append_state, None) self.assertEqual(fqaoa.backend.cvar_alpha, 1) - self.assertRaises(AttributeError, lambda: fqaoa.backend.n_shots) def test_set_backend_properties_check_backend_vectorized_w_custom(self): @@ -2099,8 +2074,7 @@ def test_set_backend_properties_check_backend_vectorized_w_custom(self): """ num_assets, budget = 5, 3 - mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) - qubo_problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo + problem = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget).qubo fqaoa = FQAOA() fqaoa.set_device(create_device(location="local", name="vectorized")) @@ -2112,51 +2086,37 @@ def test_set_backend_properties_check_backend_vectorized_w_custom(self): fqaoa.set_backend_properties(**update_pairings) - fqaoa.fermi_compile(problem=qubo_problem, n_fermions=budget) - + fqaoa.compile(problem=problem, n_fermions=budget) + orbitals = get_analytical_fermi_orbitals(n_qubits=num_assets, n_fermions=budget, lattice="cyclic", hopping=1.0) initial_state = get_statevector(orbitals) self.assertEqual(type(fqaoa.backend), QAOAvectorizedBackendSimulator) - - self.assertTrue(np.array_equal(fqaoa.backend.prepend_state, initial_state)) - self.assertEqual(fqaoa.backend.cvar_alpha, 1) - - self.assertRaises(AttributeError, lambda: fqaoa.backend.n_shots) - - def test_set_classical_optimizer_defaults(self): - pass - def test_set_classical_optimizer_jac_hess_casing(self): - pass - - def test_set_classical_optimizer_method_selectors(self): - pass + statevector = [fqaoa.backend.prepend_state, initial_state] + is_close_statevector(statevector[0], statevector[1]) - def test_set_header(self): - pass + self.assertEqual(fqaoa.backend.cvar_alpha, 1) - def test_set_exp_tags(self): - pass + self.assertRaises(AttributeError, lambda: fqaoa.backend.n_shots) - def test_qaoa_evaluate_circuit(self): + def test_fqaoa_evaluate_circuit(self): """ test the evaluate_circuit method """ # problem num_assets, budget = 5, 3 - mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) - problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo + problem = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget).qubo - # run qaoa with different param_type, and save the objcets in a list + # run qaoa with different param_type, and save the objects in a list fqaoas = [] for param_type in PARAMS_CLASSES_MAPPER.keys(): fqaoa = FQAOA() fqaoa.set_circuit_properties( p=3, param_type=param_type, init_type="rand", seed=0 ) - fqaoa.fermi_compile(problem=problem, n_fermions=budget) + fqaoa.compile(problem=problem, n_fermions=budget) fqaoas.append(fqaoa) # for each qaoa object, test the evaluate_circuit method @@ -2287,11 +2247,10 @@ def test_qaoa_evaluate_circuit(self): ): fqaoa.evaluate_circuit() - def test_qaoa_evaluate_circuit_shot(self): + def test_fqaoa_evaluate_circuit_shot(self): # problem num_assets, budget = 5, 3 - mu, sigma, _ = generate_random_portfolio_data(num_assets = num_assets, num_days = 15, seed = 1) - problem = PortfolioOptimization(mu, sigma, risk_factor = None, budget = budget, penalty = None).qubo + problem = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget).qubo if "qiskit.qasm_simulator" not in SUPPORTED_LOCAL_SIMULATORS: self.skipTest( @@ -2304,28 +2263,24 @@ def test_qaoa_evaluate_circuit_shot(self): fqaoa.set_device(device) fqaoa.set_circuit_properties(p=3) - # try to evaluate the circuit before compiling - error = False - try: - fqaoa.evaluate_circuit() - except Exception: - error = True - assert ( - error - ), f"param_type={param_type}. `evaluate_circuit` should raise an error if the circuit is not compiled" + with self.assertRaises(ValueError) as cm: + fqaoa.evaluate_circuit([1, 2, 1, 2, 1, 2]) + self.assertIn( + "Please compile the FQAOA before optimizing it!", + str(cm.exception), + ) # compile and evaluate the circuit, and check that the result is correct - fqaoa.fermi_compile(problem, budget) + fqaoa.compile(problem, budget) result = fqaoa.evaluate_circuit([1, 2, 1, 2, 1, 2]) - assert isinstance( - result["measurement_results"], dict - ), "When using a shot-based simulator, `evaluate_circuit` should return a dict of counts" - assert ( - abs(result["cost"]) >= 0 - ), "When using a shot-based simulator, `evaluate_circuit` should return a cost" - assert ( - abs(result["uncertainty"]) > 0 - ), "When using a shot-based simulator, `evaluate_circuit` should return an uncertainty" + self.assertTrue( + abs(result["cost"]) >= 0, + "When using a shot-based simulator, evaluate_circuit should return a cost" + ) + self.assertTrue( + abs(result["uncertainty"]) > 0, + "When using a shot-based simulator, evaluate_circuit should return an uncertainty" + ) cost = cost_function( result["measurement_results"], @@ -2338,17 +2293,19 @@ def test_qaoa_evaluate_circuit_shot(self): fqaoa.backend.cvar_alpha, ) uncertainty = np.sqrt(cost_sq - cost**2) - assert ( - np.round(cost, 12) == result["cost"] - ), "When using a shot-based simulator, `evaluate_circuit` not returning the correct cost" - assert ( - np.round(uncertainty, 12) == result["uncertainty"] - ), "When using a shot-based simulator, `evaluate_circuit` not returning the correct uncertainty" + self.assertTrue( + np.round(cost, 12) == result["cost"], + "When using a shot-based simulator, evaluate_circuit not returning the correct cost" + ) + self.assertTrue( + np.round(uncertainty, 12) == result["uncertainty"], + "When using a shot-based simulator, evaluate_circuit not returning the correct uncertainty" + ) def test_change_properties_after_compilation(self): device = create_device(location="local", name="vectorized") fqaoa = FQAOA() - fqaoa.fermi_compile(QUBO.random_instance(4), 2) + fqaoa.compile(QUBO.random_instance(4), 2) state_rand = np.random.rand(2**2) with self.assertRaises(ValueError): From 27766520940b0d5889977f7d854af056d79301a0 Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Wed, 4 Sep 2024 12:21:11 +0900 Subject: [PATCH 13/26] Fix typos --- examples/16_FQAOA_example.ipynb | 2 +- examples/17_FQAOA_advanced_parameterization.ipynb | 4 ++-- src/openqaoa-core/tests/test_workflows.py | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/examples/16_FQAOA_example.ipynb b/examples/16_FQAOA_example.ipynb index 31c6b79e1..2fe971d76 100644 --- a/examples/16_FQAOA_example.ipynb +++ b/examples/16_FQAOA_example.ipynb @@ -102,7 +102,7 @@ "\\prod_{i\\ {\\rm odd}}\\exp\\left[-i\\beta t\\left(\\hat{c}^{\\dagger}_i\\hat{c}_{i+1}+\\hat{c}^{\\dagger}_{i+1}\\hat{c}_{i}\\right)\\right],\n", "\\end{eqnarray}\n", "where the approximation by Trotter decomposition is applied, as certain hopping terms are non-commutative.\n", - "The implementation of the mixed unitary indicated on the right-hand side on quantum circuits is given in Refs. [[1](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071),\n", + "The implementation of the mixer unitary indicated on the right-hand side on quantum circuits is given in Refs. [[1](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071),\n", "[2](https://arxiv.org/pdf/2312.04710), [4](https://arxiv.org/pdf/1709.03489), [5](https://arxiv.org/pdf/1904.09314)]." ] }, diff --git a/examples/17_FQAOA_advanced_parameterization.ipynb b/examples/17_FQAOA_advanced_parameterization.ipynb index 73429909a..ec4fe908f 100644 --- a/examples/17_FQAOA_advanced_parameterization.ipynb +++ b/examples/17_FQAOA_advanced_parameterization.ipynb @@ -240,7 +240,7 @@ "source": [ "## FQAOA with Fourier Parameterization\n", "\n", - "To appreciate the benefits of the Fourier parameterization, let's compare the case $p=1$ using `StandardParams` with the case $q = 1, p=2$ using `FourierParams`. Here, we are optimising over the same total number of parameters, however the `FourierParams` ought to be capturing features of a more expressive circuit. \n", + "To appreciate the benefits of the Fourier parameterization, let's compare the case $p=1$ using annealing parameterization with the case $q = 1, p=2$ using `FourierParams`. Here, we are optimising over the same total number of parameters, however the `FourierParams` ought to be capturing features of a more expressive circuit. \n", "\n", "Details of the Fourier parameterization are given in Ref [[3]]((https://journals.aps.org/prx/pdf/10.1103/PhysRevX.10.021067)) and in the Notebook [`05 - QAOA circuit with advanced circuit parameterizations`](https://github.com/entropicalabs/openqaoa/blob/dev/examples/05_advanced_parameterization.ipynb)." ] @@ -330,7 +330,7 @@ "plt.ylabel('cost')\n", "plt.grid(True)\n", "plt.legend()\n", - "plt.title('Comparison of FQAOA performance between Fourier and Standard Parameterizations')\n", + "plt.title('Comparison of FQAOA performance between Fourier and Annealing Parameterizations')\n", "plt.show()" ] }, diff --git a/src/openqaoa-core/tests/test_workflows.py b/src/openqaoa-core/tests/test_workflows.py index f9e2ce06f..893e68be5 100644 --- a/src/openqaoa-core/tests/test_workflows.py +++ b/src/openqaoa-core/tests/test_workflows.py @@ -2109,7 +2109,7 @@ def test_fqaoa_evaluate_circuit(self): num_assets, budget = 5, 3 problem = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget).qubo - # run qaoa with different param_type, and save the objects in a list + # run fqaoa with different param_type, and save the objects in a list fqaoas = [] for param_type in PARAMS_CLASSES_MAPPER.keys(): fqaoa = FQAOA() @@ -2119,7 +2119,7 @@ def test_fqaoa_evaluate_circuit(self): fqaoa.compile(problem=problem, n_fermions=budget) fqaoas.append(fqaoa) - # for each qaoa object, test the evaluate_circuit method + # for each fqaoa object, test the evaluate_circuit method for fqaoa in fqaoas: # evaluate the circuit with random dict of params params = { From a7e7c86ba34097eb323c86bd950998fd49bb3da8 Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Wed, 4 Sep 2024 13:35:16 +0900 Subject: [PATCH 14/26] Enable prepend_state and update tests --- .../algorithms/fqaoa/fqaoa_workflow.py | 2 +- src/openqaoa-core/tests/test_workflows.py | 20 ++++++++----------- 2 files changed, 9 insertions(+), 13 deletions(-) diff --git a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py index d33efe463..c2690ebe0 100644 --- a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py +++ b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py @@ -788,7 +788,7 @@ def __init__( raise ValueError("In FQAOA, append_state is not recognized.") self.init_hadamard = False self.prepend_state = None - self.append_state = None + self.append_state = append_state self.n_shots = n_shots self.cvar_alpha = cvar_alpha self.noise_model = noise_model diff --git a/src/openqaoa-core/tests/test_workflows.py b/src/openqaoa-core/tests/test_workflows.py index 893e68be5..bb595a419 100644 --- a/src/openqaoa-core/tests/test_workflows.py +++ b/src/openqaoa-core/tests/test_workflows.py @@ -1415,6 +1415,10 @@ def test_qaoa_evaluate_circuit_shot(self): # compile and evaluate the circuit, and check that the result is correct q.compile(problem) result = q.evaluate_circuit([1, 2, 1, 2, 1, 2]) + self.assertIsInstance( + result["measurement_results"], dict, + "When using a shot-based simulator, evaluate_circuit should return a dict of counts" + ) self.assertTrue( abs(result["cost"]) >= 0, "When using a shot-based simulator, evaluate_circuit should return a cost" @@ -2023,18 +2027,6 @@ def test_set_backend_init_prepend_state_change(self): with self.assertRaises(ValueError): fqaoa.set_backend_properties(prepend_state=prepend_state_rand) - def test_set_backend_init_append_state_change(self): - """ - Ensure that an error occurs if the `append_state` is set by the set_backend method. - """ - - fqaoa = FQAOA() - - self.assertIsNone(fqaoa.backend_properties.append_state) - append_state_rand = np.random.rand(2**2) - with self.assertRaises(ValueError): - fqaoa.set_backend_properties(append_state=append_state_rand) - def test_set_backend_properties_check_backend_vectorized(self): """ Check if the backend returned by set_backend_properties is correct @@ -2273,6 +2265,10 @@ def test_fqaoa_evaluate_circuit_shot(self): # compile and evaluate the circuit, and check that the result is correct fqaoa.compile(problem, budget) result = fqaoa.evaluate_circuit([1, 2, 1, 2, 1, 2]) + self.assertIsInstance( + result["measurement_results"], dict, + "When using a shot-based simulator, evaluate_circuit should return a dict of counts" + ) self.assertTrue( abs(result["cost"]) >= 0, "When using a shot-based simulator, evaluate_circuit should return a cost" From 5207488999ad029831513f42f2afe89c34ee0cff Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Thu, 5 Sep 2024 09:39:27 +0900 Subject: [PATCH 15/26] Reduce complexity and reorganize notebook for better structure --- examples/16_FQAOA_example.ipynb | 294 +++++------------- .../17_FQAOA_advanced_parameterization.ipynb | 137 +++----- 2 files changed, 122 insertions(+), 309 deletions(-) diff --git a/examples/16_FQAOA_example.ipynb b/examples/16_FQAOA_example.ipynb index 2fe971d76..5fbc6ee94 100644 --- a/examples/16_FQAOA_example.ipynb +++ b/examples/16_FQAOA_example.ipynb @@ -32,7 +32,7 @@ "This notebook describes the implementation of FQAOA, illustrates its application through various examples, and provides insight into FQAOA's superior performance in constrained combinatorial optimization tasks.\n", "\n", "### Quadratic Constrained Binary Optimization Problems\n", - "The constrained combinatorial optimization problem for a polynomial cost function　$C_{\\boldsymbol x}$ covered here can be written in the following form：\n", + "The constrained combinatorial optimization problem for a quadratic binary cost function　$C_{\\boldsymbol x}$ can be written in the following form：\n", "$${\\boldsymbol x}^* = \\arg \\min_{\\boldsymbol x} C_{\\boldsymbol x}\\qquad {\\rm s.t.} \\quad\\sum_{i=1}^{N} x_i = M,$$\n", "with bit string ${\\boldsymbol x}\\in \\{0,1\\}^N$, where ${\\boldsymbol x}^*$ is the optimal solution.\n", "This problem can be replaced by the minimum eigenvalue problem in the following steps.\n", @@ -75,7 +75,7 @@ "The specific mixer Hamiltonian $\\hat{\\cal H}_M$ on cyclic lattice to be implemented in OpenQAOA are as follow:\n", "\n", "\\begin{eqnarray}\n", - "\\hat{\\cal H}_M &=& t\\sum_{i=1}^{N-1} (\\hat{c}^\\dagger_i\\hat{c}_{i+1}+\\hat{c}^\\dagger_{i+1}\\hat{c}_i)-t(-1)^{M}(\\hat{c}^\\dagger_N\\hat{c}_{1}+\\hat{c}^\\dagger_{1}\\hat{c}_N).\n", + "\\hat{\\cal H}_M &=& -t\\sum_{i=1}^{N-1} (\\hat{c}^\\dagger_i\\hat{c}_{i+1}+\\hat{c}^\\dagger_{i+1}\\hat{c}_i)-t(-1)^{M-1}(\\hat{c}^\\dagger_N\\hat{c}_{1}+\\hat{c}^\\dagger_{1}\\hat{c}_N).\n", "\\end{eqnarray}\n", "These Hamiltonians can be diagonalized as:\n", "$$\\hat{\\cal H}_M=\\sum_{i=1}^{N}\\varepsilon_i\\hat{\\gamma}_i^\\dagger\\hat{\\gamma}_i \\qquad {\\rm with} \\quad\n", @@ -97,9 +97,9 @@ "- mixing unitary $U(\\hat{\\cal H}_M, \\beta)$ on cyclic lattice:\n", "\\begin{eqnarray}\n", "U(\\hat{\\cal H}_M, \\beta) &\\sim&\n", - "\\exp\\left[i\\beta t(-1)^M\\left(\\hat{c}^{\\dagger}_{ND}\\hat{c}_{1}+\\hat{c}^{\\dagger}_{1}\\hat{c}_{ND}\\right)\\right]\n", - "\\prod_{i\\ {\\rm even}}\\exp\\left[-i\\beta t\\left(\\hat{c}^{\\dagger}_i\\hat{c}_{i+1}+\\hat{c}^{\\dagger}_{i+1}\\hat{c}_{i}\\right)\\right]\n", - "\\prod_{i\\ {\\rm odd}}\\exp\\left[-i\\beta t\\left(\\hat{c}^{\\dagger}_i\\hat{c}_{i+1}+\\hat{c}^{\\dagger}_{i+1}\\hat{c}_{i}\\right)\\right],\n", + "\\exp\\left[i\\beta t(-1)^{M-1}\\left(\\hat{c}^{\\dagger}_{ND}\\hat{c}_{1}+\\hat{c}^{\\dagger}_{1}\\hat{c}_{ND}\\right)\\right]\n", + "\\prod_{i\\ {\\rm even}}\\exp\\left[i\\beta t\\left(\\hat{c}^{\\dagger}_i\\hat{c}_{i+1}+\\hat{c}^{\\dagger}_{i+1}\\hat{c}_{i}\\right)\\right]\n", + "\\prod_{i\\ {\\rm odd}}\\exp\\left[i\\beta t\\left(\\hat{c}^{\\dagger}_i\\hat{c}_{i+1}+\\hat{c}^{\\dagger}_{i+1}\\hat{c}_{i}\\right)\\right],\n", "\\end{eqnarray}\n", "where the approximation by Trotter decomposition is applied, as certain hopping terms are non-commutative.\n", "The implementation of the mixer unitary indicated on the right-hand side on quantum circuits is given in Refs. [[1](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071),\n", @@ -122,12 +122,9 @@ "\n", "# method to covnert a docplex model to a qubo problem\n", "from openqaoa.problems import PortfolioOptimization\n", - "from openqaoa.backends import create_device\n", - "from openqaoa.utilities import bitstring_energy\n", "\n", "# Import external libraries to present an manipulate the data\n", "import pandas as pd\n", - "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, @@ -138,25 +135,8 @@ "source": [ "## Portfolio Optimization\n", "\n", - "In the following, the [portfolio optimization problem](https://en.wikipedia.org/wiki/Portfolio_optimization) is taken as a constrained quadratic formal optimisation problem.\n", - "\n", - "$$\\min_{x} : q {\\boldsymbol x}^{T} {\\boldsymbol \\sigma} {\\boldsymbol x}-{\\boldsymbol\\mu}^{T} {\\boldsymbol x},\\qquad {\\rm s.t.} \\quad\\sum_{i=1}^{N} x_i = M,$$\n", - "\n", - "where:\n", - "- $N$: number of decision variables,\n", - "- ${\\boldsymbol x} \\in\\{0,1\\}^{N}$: vector of binary decision variables,\n", - "- ${\\boldsymbol \\mu} \\in R^{n}$: vector coefficients for the linear term,\n", - "- ${\\boldsymbol \\sigma} \\in R^{n \\times n}$: symmetric positive semidefinite matrix for quadratic term,\n", - "- $q$: quadratic term coefficient,\n", - "- $M$: constraint on the sum of decision variables." - ] - }, - { - "cell_type": "markdown", - "id": "bb6a05c9-82f7-431b-b60f-de61cd71d3cf", - "metadata": {}, - "source": [ - "Start by creating an instance of the portfolio optimisation problem, using the `random_instance` method of `the PortfolioOptimisation` class." + "In the following, the [portfolio optimization problem](https://en.wikipedia.org/wiki/Portfolio_optimization) is taken as a constrained quadratic optimisation problem.\n", + "Start by creating an instance of the portfolio optimisation problem, using the `random_instance` method of the `PortfolioOptimisation`." ] }, { @@ -167,8 +147,8 @@ "outputs": [], "source": [ "# create a problem instance for portfolio optimization\n", - "num_assets = 8 # number of assets\n", - "budget = 4 # budget constraint value\n", + "num_assets = 8 # number of decision variables\n", + "budget = 4 # constraint on the sum of decision variables\n", "problem = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget, penalty = None).qubo" ] }, @@ -180,35 +160,25 @@ "## Solving the problem" ] }, - { - "cell_type": "code", - "execution_count": 3, - "id": "6d2328a6-88f2-4a85-964e-d00f036d044a", - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "# Indicate the device, this case is a local simulator\n", - "device = create_device('local', 'qiskit.statevector_simulator')" - ] - }, { "cell_type": "markdown", "id": "f54c48a2", "metadata": {}, "source": [ - "The quantum algorithms consider the following properties: the qiskit's statevector_simulator backend with a `p` value equals to 2, with `ramp` initialization." + "The simplest QAOA and FQAOA workflows." ] }, { - "cell_type": "markdown", - "id": "f7eb209f-387b-4987-b642-e76f61168cf1", + "cell_type": "code", + "execution_count": 3, + "id": "0ee8df0b-e25d-4f9b-8304-1bdff0acb64b", "metadata": {}, + "outputs": [], "source": [ - "### FQAOA Optimization\n", - "\n", - "Here, a fermionic mixer Hamiltonian $\\hat{\\cal H}_M$ on cyclic lattice determines its ground state as the initial state $\\hat{U}_{\\rm init}|\\rm vac\\rangle$ and its mixer $U(\\hat{\\cal H}_M, \\beta)$." + "# conventional QAOA workflow\n", + "qaoa = QAOA()\n", + "qaoa.compile(problem = problem)\n", + "qaoa.optimize()" ] }, { @@ -218,35 +188,10 @@ "metadata": {}, "outputs": [], "source": [ - "fqaoa = FQAOA(device)\n", - "fqaoa.set_circuit_properties(p=2)\n", + "# FQAOA workflow\n", + "fqaoa = FQAOA()\n", "fqaoa.compile(problem = problem, n_fermions = budget)\n", - "fqaoa.optimize()\n", - "fqaoa_results = fqaoa.result" - ] - }, - { - "cell_type": "markdown", - "id": "4c4dd7b9-0389-4689-a4fd-52917e6d7b06", - "metadata": {}, - "source": [ - "### Conventional QAOA Optimization\n", - "\n", - "Here, the conventional X-mixer Hamiltonian $H_M$ determines its ground state as the initial state and its unitary transformation $\\exp(-i\\beta\\hat{\\cal H}_M)$ as the mixer." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "0ee8df0b-e25d-4f9b-8304-1bdff0acb64b", - "metadata": {}, - "outputs": [], - "source": [ - "qaoa = QAOA(device)\n", - "qaoa.set_circuit_properties(p=2)\n", - "qaoa.compile(problem = problem)\n", - "qaoa.optimize()\n", - "qaoa_results = qaoa.result" + "fqaoa.optimize()" ] }, { @@ -254,69 +199,19 @@ "id": "5bf46716-6f89-4e00-bbae-cbe8a991055e", "metadata": {}, "source": [ - "### Performance Evaluation of FQAOA" - ] - }, - { - "cell_type": "markdown", - "id": "7571203b-664e-40c9-ba7d-209372403a80", - "metadata": {}, - "source": [ - "To evaluate the performance of FQAOA, we show expectation value of costs. \n", - "We define normalized costs by \n", - "$\\Delta C_{\\boldsymbol x}/W$ with $\\Delta C_{\\boldsymbol x} = (C_{\\boldsymbol x}-C_{\\rm min})$ and $W=(C_{\\rm max}-C_{\\rm min})$, where $C_{\\rm max}$ ($C_{\\rm min}$) is maximum (minimum) value of cost under the constraint." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "fe328715-f5ef-4422-aae4-a5e9dd745942", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(min C_x, max C_x) = ( -1.3716497056878048 2.5829135601546653 )\n" - ] - } - ], - "source": [ - "x_in_constraint = []\n", - "for i in range(2**num_assets):\n", - " bit = bin(i)[2:].zfill(num_assets)\n", - " cost = bitstring_energy(qaoa.cost_hamil, bit[::-1])\n", - " if bit.count('1') == budget:\n", - " x_in_constraint.append(cost)\n", - "C_max, C_min = max(x_in_constraint), min(x_in_constraint)\n", - "print('(min C_x, max C_x) = ', '(', C_min, C_max,')')" + "## Performance Evaluation of FQAOA\n", + "To evaluate the performance of FQAOA, we show expectation value of costs. " ] }, { "cell_type": "code", - "execution_count": 7, - "id": "9b2c0b91-4de0-4362-9470-1d7a354e5418", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "label_list = ['QAOA', 'FQAOA']\n", - "opt_results_list, cost_list = [], []\n", - "exp_cost_dict = {}\n", - "for opt_result in [qaoa_results, fqaoa_results]:\n", - " opt_results_list.append(opt_result)\n", - " cost_list.append(opt_result.optimized['cost'])" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "5125af92-c141-4aae-813c-e2f27956d1c2", + "execution_count": 5, + "id": "e02d09a9-6c15-4539-accd-c4df75692f74", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -326,39 +221,27 @@ } ], "source": [ + "labels = ['QAOA', 'FQAOA']\n", + "\n", "# plot cost history\n", - "for i, opt_result in enumerate([qaoa_results, fqaoa_results]):\n", - " cost = opt_result.intermediate['cost']\n", - " cost = [(cost[i]-C_min)/(C_max-C_min) for i in range(len(cost))]\n", - " plt.plot(cost, ls='--')\n", - "plt.title('Cost history')\n", - "plt.grid(True)\n", - "plt.xlabel('number of functions evaluations')\n", - "plt.ylabel(r'normalized cost, $\\langle \\Delta C_{\\boldsymbol{x}}/W \\rangle$')\n", + "fig, ax = plt.subplots()\n", + "for i, result in enumerate([qaoa.result, fqaoa.result]):\n", + " result.plot_cost(ax=ax, color=f'C{i}', label=labels[i])\n", + "ax.grid(True)\n", "plt.show()" ] }, - { - "cell_type": "markdown", - "id": "9c6dda49-9fb0-4235-9a7d-8e6ba14ecebf", - "metadata": {}, - "source": [ - "### Performance Evaluation of FQAOA" - ] - }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "id": "e620d83e-0a6c-433a-af44-1b7a04f0d491", - "metadata": { - "scrolled": true - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "expectation values of the costs.\n" + "optimized expectation values of the cost\n" ] }, { @@ -382,36 +265,29 @@ " \n", " \n", " \n", - " method\n", - " $\\langle C_{\\boldsymbol x} \\rangle$\n", - " $\\langle \\Delta C_{\\boldsymbol x}\\rangle /W$\n", + " Method\n", + " Optimized Cost $\\langle C_{\\boldsymbol x} \\rangle$\n", " \n", " \n", " \n", " \n", " 0\n", " QAOA\n", - " 6.928124\n", - " 2.098784\n", + " 4.512233\n", " \n", " \n", " 1\n", " FQAOA\n", - " -0.543982\n", - " 0.209294\n", + " -0.482998\n", " \n", " \n", "\n", "" ], "text/plain": [ - " method $\\langle C_{\\boldsymbol x} \\rangle$ \\\n", - "0 QAOA 6.928124 \n", - "1 FQAOA -0.543982 \n", - "\n", - " $\\langle \\Delta C_{\\boldsymbol x}\\rangle /W$ \n", - "0 2.098784 \n", - "1 0.209294 " + " Method Optimized Cost $\\langle C_{\\boldsymbol x} \\rangle$\n", + "0 QAOA 4.512233 \n", + "1 FQAOA -0.482998 " ] }, "metadata": {}, @@ -419,19 +295,19 @@ } ], "source": [ - "# evaluate the expection values of the cost\n", - "exp_cost_dict['method'] = label_list\n", - "exp_cost_dict[r'$\\langle C_{\\boldsymbol x} \\rangle$'] = cost_list\n", - "exp_cost_dict[r'$\\langle \\Delta C_{\\boldsymbol x}\\rangle /W$'] = (np.array(cost_list)-C_min)/(C_max-C_min)\n", + "# evaluate optimized expectation values of the cost\n", + "exp_cost_dict = {\n", + " 'Method': labels,\n", + " r'Optimized Cost $\\langle C_{\\boldsymbol x} \\rangle$':[qaoa.result.optimized['cost'], fqaoa.result.optimized['cost']]\n", + "}\n", "df = pd.DataFrame(exp_cost_dict)\n", - "\n", - "print(r'expectation values of the costs.')\n", + "print('optimized expectation values of the cost')\n", "display(df)" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "id": "6373b123-b0d2-44db-a4d6-5d2ca44185d8", "metadata": {}, "outputs": [ @@ -439,7 +315,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Comparison of methods for calculating the probability of finding the optimal solutions\n" + "probabilities of finding the best five optimal solutions\n" ] }, { @@ -463,11 +339,10 @@ " \n", " \n", " \n", - " bitstrings, $\\boldsymbol{x}$\n", - " $C_{\\boldsymbol x}$\n", - " $\\Delta C_{\\boldsymbol x}/W$\n", - " Probability (QAOA)\n", - " Probability (FQAOA)\n", + " Bitstring, $\\boldsymbol{x}$\n", + " Cost, $C_{\\boldsymbol x}$\n", + " QAOA\n", + " FQAOA\n", " \n", " \n", " \n", @@ -475,60 +350,48 @@ " 0\n", " 11100001\n", " -1.371650\n", - " 0.000000\n", - " 0.006734\n", - " 0.015174\n", + " 0.005642\n", + " 0.009979\n", " \n", " \n", " 1\n", " 11101000\n", " -1.193696\n", - " 0.045000\n", - " 0.007045\n", - " 0.020652\n", + " 0.006019\n", + " 0.024488\n", " \n", " \n", " 2\n", " 10101001\n", " -1.080295\n", - " 0.073675\n", - " 0.006668\n", - " 0.227928\n", + " 0.006139\n", + " 0.192331\n", " \n", " \n", " 3\n", " 10110001\n", " -1.079240\n", - " 0.073942\n", - " 0.005627\n", - " 0.096106\n", + " 0.005780\n", + " 0.044356\n", " \n", " \n", " 4\n", " 11100100\n", " -0.949303\n", - " 0.106800\n", - " 0.005812\n", - " 0.016974\n", + " 0.006036\n", + " 0.020335\n", " \n", " \n", "\n", "" ], "text/plain": [ - " bitstrings, $\\boldsymbol{x}$ $C_{\\boldsymbol x}$ \\\n", - "0 11100001 -1.371650 \n", - "1 11101000 -1.193696 \n", - "2 10101001 -1.080295 \n", - "3 10110001 -1.079240 \n", - "4 11100100 -0.949303 \n", - "\n", - " $\\Delta C_{\\boldsymbol x}/W$ Probability (QAOA) Probability (FQAOA) \n", - "0 0.000000 0.006734 0.015174 \n", - "1 0.045000 0.007045 0.020652 \n", - "2 0.073675 0.006668 0.227928 \n", - "3 0.073942 0.005627 0.096106 \n", - "4 0.106800 0.005812 0.016974 " + " Bitstring, $\\boldsymbol{x}$ Cost, $C_{\\boldsymbol x}$ QAOA FQAOA\n", + "0 11100001 -1.371650 0.005642 0.009979\n", + "1 11101000 -1.193696 0.006019 0.024488\n", + "2 10101001 -1.080295 0.006139 0.192331\n", + "3 10110001 -1.079240 0.005780 0.044356\n", + "4 11100100 -0.949303 0.006036 0.020335" ] }, "metadata": {}, @@ -537,18 +400,17 @@ ], "source": [ "# Print the best 5 solutions\n", - "lowest_dict = opt_results_list[0].lowest_cost_bitstrings(5)\n", - "list1 = lowest_dict['bitstrings_energies']\n", - "normalized_cost = [(x - C_min) / (C_max - C_min) for x in list1]\n", + "qaoa_lowest5_dict = qaoa.result.lowest_cost_bitstrings(5)\n", + "fqaoa_lowest5_dict = fqaoa.result.lowest_cost_bitstrings(5)\n", + "\n", "qaoa_dict = {\n", - " r'bitstrings, $\\boldsymbol{x}$': lowest_dict['solutions_bitstrings'],\n", - " r'$C_{\\boldsymbol x}$': list1,\n", - " r'$\\Delta C_{\\boldsymbol x}/W$': normalized_cost,\n", - " f'Probability ({label_list[0]})': lowest_dict.pop('probabilities'),\n", - " f'Probability ({label_list[1]})': opt_results_list[1].lowest_cost_bitstrings(5)['probabilities']\n", + " r'Bitstring, $\\boldsymbol{x}$': qaoa_lowest5_dict['solutions_bitstrings'],\n", + " r'Cost, $C_{\\boldsymbol x}$': qaoa_lowest5_dict['bitstrings_energies'],\n", + " labels[0]: qaoa_lowest5_dict['probabilities'],\n", + " labels[1]: fqaoa_lowest5_dict['probabilities']\n", "}\n", "df = pd.DataFrame(qaoa_dict)\n", - "print('Comparison of methods for calculating the probability of finding the optimal solutions')\n", + "print('probabilities of finding the best five optimal solutions')\n", "display(df)" ] }, diff --git a/examples/17_FQAOA_advanced_parameterization.ipynb b/examples/17_FQAOA_advanced_parameterization.ipynb index ec4fe908f..f54c272af 100644 --- a/examples/17_FQAOA_advanced_parameterization.ipynb +++ b/examples/17_FQAOA_advanced_parameterization.ipynb @@ -26,15 +26,9 @@ "\n", "# method to covnert a docplex model to a qubo problem\n", "from openqaoa.problems import PortfolioOptimization\n", - "from openqaoa.backends import create_device\n", - "from openqaoa.utilities import bitstring_energy\n", "\n", "# Import external libraries to present an manipulate the data\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Indicate the device, this case is a local simulator\n", - "device = create_device('local', 'vectorized')" + "import matplotlib.pyplot as plt" ] }, { @@ -105,59 +99,58 @@ "id": "f7eb209f-387b-4987-b642-e76f61168cf1", "metadata": {}, "source": [ - "### Running QA using FQAOA Ansatz" + "### Running QA" ] }, { "cell_type": "code", "execution_count": 3, + "id": "b1c8a507-e592-42c8-b29b-aff991a16f5d", + "metadata": {}, + "outputs": [], + "source": [ + "# set maximum annealing time\n", + "Tmax = 2.0" + ] + }, + { + "cell_type": "code", + "execution_count": 4, "id": "11087210-d89c-4b4d-a85a-576a1faad80f", "metadata": { "scrolled": true }, "outputs": [], "source": [ - "# QA using FQAOA\n", - "fqaoa_cost_list = []\n", - "fqaoa_ip_values = range(1, 11)\n", + "# QA using FQAOA ansatz\n", "fqaoa_dt = 0.2\n", - "\n", - "for ip in fqaoa_ip_values:\n", - " fqaoa = FQAOA(device)\n", + "fqaoa_cost_list = []\n", + "for ip in range(1, int(Tmax/fqaoa_dt)+1):\n", + " fqaoa = FQAOA()\n", " fqaoa.set_circuit_properties(p=ip, param_type='annealing', init_type='ramp', annealing_time=fqaoa_dt*ip)\n", " fqaoa.set_classical_optimizer(maxiter=0)\n", " fqaoa.compile(problem = problem, n_fermions = budget)\n", " fqaoa.optimize()\n", - " fqaoa_cost_list.append(fqaoa.result.optimized['cost'])" - ] - }, - { - "cell_type": "markdown", - "id": "4c4dd7b9-0389-4689-a4fd-52917e6d7b06", - "metadata": {}, - "source": [ - "### Running QA using QAOA Ansatz" + " fqaoa_cost_list.append([ip*fqaoa_dt, fqaoa.result.optimized['cost']])" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "0ee8df0b-e25d-4f9b-8304-1bdff0acb64b", "metadata": {}, "outputs": [], "source": [ - "# QA using QAOA\n", - "qaoa_cost_list = []\n", - "qaoa_ip_values = range(1, 101)\n", + "# QA using QAOA ansatz\n", "qaoa_dt = 0.02\n", - "\n", - "for ip in qaoa_ip_values:\n", - " qaoa = QAOA(device)\n", + "qaoa_cost_list = []\n", + "for ip in range(1, int(Tmax/qaoa_dt)+1):\n", + " qaoa = QAOA()\n", " qaoa.set_circuit_properties(p=ip, param_type='annealing', init_type='ramp', annealing_time=qaoa_dt*ip)\n", " qaoa.set_classical_optimizer(maxiter=0)\n", " qaoa.compile(problem = problem)\n", " qaoa.optimize()\n", - " qaoa_cost_list.append(qaoa.result.optimized['cost'])" + " qaoa_cost_list.append([ip*qaoa_dt, qaoa.result.optimized['cost']])" ] }, { @@ -165,36 +158,9 @@ "id": "ef9f898f-32fa-471d-8fb3-3d97a7b1b0d7", "metadata": {}, "source": [ - "## Performance Evaluation of QA with FQAOA\n", + "### Performance Evaluation of FQAOA Ansatz in QA\n", "\n", - "To evaluate the performance of FQAOA, we show expectation value of costs. \n", - "We define normalized costs by \n", - "$\\Delta C_{\\boldsymbol x}/W$ with $\\Delta C_{\\boldsymbol x} = (C_{\\boldsymbol x}-C_{\\rm min})$ and $W=(C_{\\rm max}-C_{\\rm min})$, where $C_{\\rm max}$ ($C_{\\rm min}$) is maximum (minimum) value of cost under the constraint." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "4107fd95-d4a1-44ad-abf4-70bc50b7b5e2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(min C_x, max C_x) = ( -1.7800188086068625 0.7095615310972656 )\n" - ] - } - ], - "source": [ - "x_in_constraint = []\n", - "for i in range(2**num_assets):\n", - " bit = bin(i)[2:].zfill(num_assets)\n", - " cost = bitstring_energy(qaoa.cost_hamil, bit[::-1])\n", - " if bit.count('1') == budget:\n", - " x_in_constraint.append(cost)\n", - "max_x, min_x = max(x_in_constraint), min(x_in_constraint)\n", - "print('(min C_x, max C_x) = ', '(', min_x, max_x,')')" + "To evaluate the performance of the QA using FQAOA ansatz, we show expectation values of cost." ] }, { @@ -205,7 +171,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -216,19 +182,14 @@ ], "source": [ "# Plotting costs against annealing time\n", - "fqaoa_annealing_times = [ip * fqaoa_dt for ip in fqaoa_ip_values]\n", - "fqaoa_cost_list = [(fqaoa_cost_list[i]-min_x)/(max_x-min_x) for i in range(len(fqaoa_cost_list))]\n", - "qaoa_annealing_times = [ip * qaoa_dt for ip in qaoa_ip_values]\n", - "qaoa_cost_list = [(qaoa_cost_list[i]-min_x)/(max_x-min_x) for i in range(len(qaoa_cost_list))]\n", - "\n", - "# Plotting the results\n", - "fqaoa_cost_list\n", - "plt.plot(fqaoa_annealing_times, fqaoa_cost_list, marker='o', label='FQAOA')\n", - "plt.plot(qaoa_annealing_times, qaoa_cost_list, marker='x', label='QAOA')\n", + "labels = ['QAOA', 'FQAOA']\n", + "for i, cost_list in enumerate([qaoa_cost_list, fqaoa_cost_list]):\n", + " x, y = zip(*cost_list)\n", + " plt.plot(x, y, label=labels[i])\n", "plt.xlabel('Annealing Time $T$')\n", "plt.ylabel('Cost')\n", - "plt.title(r'Quantum Annealing Cost vs. Annealing Time')\n", - "plt.grid(True, which='both')\n", + "plt.title(r'Cost vs. Annealing Time')\n", + "plt.grid(True)\n", "plt.legend()\n", "plt.show()" ] @@ -247,10 +208,10 @@ }, { "cell_type": "markdown", - "id": "a147232a-3a4f-47d3-82a7-db8757bfa0ec", + "id": "4bb26ad2-8b2d-41a0-a8e2-b6e53da11c3e", "metadata": {}, "source": [ - "### Fourier Parameterization" + "### Solving the problem using advanced parameterization" ] }, { @@ -260,6 +221,7 @@ "metadata": {}, "outputs": [], "source": [ + "# fourier parametrization\n", "p_fourier = 3\n", "q = 1\n", "\n", @@ -269,14 +231,6 @@ "fq_fourier.optimize()" ] }, - { - "cell_type": "markdown", - "id": "8ecbdf29-4cc3-42b4-827a-cdd6b4069666", - "metadata": {}, - "source": [ - "### Annealing Parameterization" - ] - }, { "cell_type": "code", "execution_count": 8, @@ -284,6 +238,7 @@ "metadata": {}, "outputs": [], "source": [ + "# annealing parametrization\n", "p_annealing = 1\n", "\n", "fq_annealing = FQAOA()\n", @@ -297,18 +252,18 @@ "id": "66b12bb6-db7f-4caf-83b3-216151cb1d88", "metadata": {}, "source": [ - "## Performance Evaluation of FQAOA with Fourier Parameterization" + "### Performance Evaluation of FQAOA with Fourier Parameterization" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "id": "104e1c25-d674-4813-b706-f899b8fd23c6", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -321,16 +276,12 @@ "labels = [f'FQAOA with fourier params (p={p_fourier}, q={q})',\n", " f'FQAOA with annealing params (p={p_annealing})',]\n", "\n", - "for i, fqaoa in enumerate([fq_fourier, fq_annealing]):\n", - " cost = fqaoa.result.intermediate['cost']\n", - " cost = [(cost[i]-min_x)/(max_x-min_x) for i in range(len(cost))]\n", - " plt.plot(cost, label=labels[i], ls='--')\n", - "\n", - "plt.xlabel('Number of function evaluations')\n", - "plt.ylabel('cost')\n", + "# plot cost history\n", + "fig, ax = plt.subplots()\n", + "for i, result in enumerate([fq_fourier.result, fq_annealing.result]):\n", + " result.plot_cost(ax=ax, color=f'C{i}', label=labels[i])\n", "plt.grid(True)\n", "plt.legend()\n", - "plt.title('Comparison of FQAOA performance between Fourier and Annealing Parameterizations')\n", "plt.show()" ] }, From 9c607cc6c6793b3c6f9fda24d5cc0c3402b74db9 Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Fri, 6 Sep 2024 17:48:23 +0900 Subject: [PATCH 16/26] Refine docstrings for improved clarity and accuracy --- .../openqaoa/algorithms/fqaoa/fqaoa_utils.py | 12 +- .../algorithms/fqaoa/fqaoa_workflow.py | 132 +++++++++--------- 2 files changed, 71 insertions(+), 73 deletions(-) diff --git a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py index 53c985c90..94dfebcca 100644 --- a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py +++ b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py @@ -5,7 +5,7 @@ ALLOWED_LATTICE = ["cyclic", "chain"] -def get_givens_rotation_angle(orbitals: np.array) -> List[float]: +def get_givens_rotation_angle(orbitals: np.ndarray) -> List[float]: """ Compute the Givens rotation angles for transforming the orbital matrix `orbitals`. @@ -16,7 +16,7 @@ def get_givens_rotation_angle(orbitals: np.array) -> List[float]: Parameters ---------- - orbitals : np.array + orbitals : numpy.ndarray A 2D NumPy array representing the matrix of orbitals. The matrix should have a shape of (n_fermions, n_qubits), where `n_fermions` is the number of rows and `n_qubits` is the number of columns. @@ -66,13 +66,13 @@ def get_givens_rotation_angle(orbitals: np.array) -> List[float]: return gtheta -def get_statevector(orbitals: np.array) -> np.ndarray: +def get_statevector(orbitals: np.ndarray) -> np.ndarray: """ Compute the statevector from fermionic orbitals. Parameters ---------- - orbitals : np.array + orbitals : np.ndarray A 2D NumPy array representing the matrix of orbitals. The matrix should have a shape of (n_fermions, n_qubits), where `n_fermions` is the number of rows and `n_qubits` is the number of columns. @@ -297,7 +297,7 @@ def generate_random_portfolio_data( # Generate historical-like data for multiple assets over a number of days random_asset_factors = (1 - 2 * np.random.rand(num_assets)).reshape(-1, 1) - day_indices = np.array([np.arange(num_days) for i in range(num_assets)]) + np.random.randint(10) + day_indices = np.ndarray([np.arange(num_days) for i in range(num_assets)]) + np.random.randint(10) random_fluctuations = 1 - 2 * np.random.rand(num_assets, num_days) # The resulting matrix hist_exp represents the daily returns or price levels of the assets @@ -359,7 +359,7 @@ def _get_free_eigen( return eig[1] -def _unitary_sparsification(orbitals: np.array) -> np.ndarray: +def _unitary_sparsification(orbitals: np.ndarray) -> np.ndarray: """ Perform a unitary transformation to sparsify a matrix `orbitals` by setting the elements in the upper triangular region to zero. diff --git a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py index c2690ebe0..d814ef569 100644 --- a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py +++ b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py @@ -3,7 +3,6 @@ import numpy as np from .fqaoa_utils import ( - get_analytical_fermi_orbitals, get_fermi_orbitals, get_statevector, get_givens_rotation_angle, @@ -76,7 +75,7 @@ class FQAOA(Workflow): The circuit properties of the FQAOA workflow. Use to set depth `p`, choice of parameterization, parameter initialisation strategies, mixer hamiltonians. For a complete list of its parameters and usage please see the method `set_circuit_properties` - backend_properties: `BackendProperties` + backend_properties: `FermiBackendProperties` The backend properties of the FQAOA workflow. Use to set the backend properties such as the number of shots and the cvar values. For a complete list of its parameters and usage please see the method `set_backend_properties` @@ -107,8 +106,10 @@ class FQAOA(Workflow): Examples -------- - Examples should be written in doctest format, and should illustrate how - to use the function. + Basic usage with default settings: + + Initialize FQAOA with default parameters. This approach is straightforward and uses standard configurations. + This is suitable when the problem's requirements align with the default settings of FQAOA. >>> fqaoa = FQAOA() >>> fqaoa.compile(problem, n_fermions) @@ -117,7 +118,10 @@ class FQAOA(Workflow): Where `problem` is an instance of `openqaoa.problems.problem.QUBO` with hamming weight constant constraint, where `n_fermions` is a constraint value. - If you want to use non-default parameters: + Custom usage with non-default parameters: + + If your problem requires specific configurations or optimization strategies, you can customize the FQAOA instance + by setting circuit properties, choosing a different device, adjusting backend settings, or selecting a different classical optimizer. >>> fqaoa_custom = FQAOA() >>> fqaoa_custom.set_circuit_properties( @@ -177,15 +181,44 @@ def set_device(self, device: DeviceBase): @check_compiled def set_backend_properties(self, **kwargs): """ - Override set_backend_properties to use FermiBackendProperties. + Specify the backend properties to construct FQAOA circuit Parameters ---------- - **kwargs : dict - Keyword arguments representing backend properties. - - - init_hadamard : bool - Whether to apply the Hadamard gate during initialization. This will be overridden to False. + device: DeviceBase + The device to use for the backend. + prepend_state: Union[openqaoa.basebackend.QuantumCircuitBase,numpy.ndarray(complex)] + The initial state for FQAOA is specified within the `FQAOA.compile` method, and therefore + `prepend_state` should not be set here. Providing a value for this property will + raise a ValueError. + append_state: Union[QuantumCircuitBase,numpy.ndarray(complex)] + The state appended to the circuit. + init_hadamard: bool + Specifies whether to apply the Hadamard gate during initialization. + This is always set to `False` in FQAOA and will raise a ValueError if set to `True`. + n_shots: int + The number of shots to be used for the shot-based computation. + cvar_alpha: float + The value of the CVaR parameter. + noise_model: NoiseModel + The `qiskit` noise model to be used for the shot-based simulator. + initial_qubit_mapping: Union[List[int], numpy.ndarray] + Mapping from physical to logical qubit indices, used to eventually + construct the quantum circuit. For example, for a system composed by 3 qubits + `qubit_layout=[1,3,2]`, maps `1<->0`, `3<->1`, `2<->2`, where the left hand side is the physical qubit + and the right hand side is the logical qubits + qiskit_simulation_method: str + Specify the simulation method to use with the `qiskit.AerSimulator` + qiskit_optimization_level: int, optional + Specify the qiskit.transpile optimization level. Choose from 0,1,2,3 + seed_simulator: int + Specify a seed for `qiskit` simulators + active_reset: bool + To use the active_reset functionality on Rigetti backends through QCS + rewiring: str + Specify the rewiring strategy for compilation for Rigetti QPUs through QCS + disable_qubit_rewiring: bool + enable/disable qubit rewiring when accessing QPUs via the AWS `braket` """ for key, value in kwargs.items(): @@ -195,7 +228,6 @@ def set_backend_properties(self, **kwargs): raise ValueError( f"Specified argument `{value}` for `{key}` in set_backend_properties is not supported" ) - self.backend_properties = FermiBackendProperties(**kwargs) return None @@ -203,21 +235,21 @@ def set_backend_properties(self, **kwargs): @check_compiled def set_circuit_properties(self, **kwargs): """ - Specify the circuit properties to construct QAOA circuit + Specify the circuit properties to construct FQAOA circuit Parameters ---------- qubit_register: `list` - Select the desired qubits to run the QAOA program. Meant to be used as a qubit + Select the desired qubits to run the FQAOA program. Meant to be used as a qubit selector for qubits on a QPU. Defaults to a list from 0 to n-1 (n = number of qubits) p: `int` - Depth `p` of the QAOA circuit + Depth `p` of the FQAOA circuit q: `int` - Analogue of `p` of the QAOA circuit in the Fourier parameterization + Analogue of `p` of the FQAOA circuit in the Fourier parameterization param_type: `str` - Choose the QAOA circuit parameterization. Currently supported parameterizations include: - `'standard'`: Standard QAOA parameterization - `'standard_w_bias'`: Standard QAOA parameterization with a separate parameter for single-qubit terms. + Choose the FQAOA circuit parameterization. Currently supported parameterizations include: + `'standard'`: Standard FQAOA parameterization + `'standard_w_bias'`: Standard FQAOA parameterization with a separate parameter for single-qubit terms. `'extended'`: Individual parameter for each qubit and each term in the Hamiltonian. `'fourier'`: Fourier circuit parameterization `'fourier_extended'`: Fourier circuit parameterization with individual parameter @@ -225,7 +257,7 @@ def set_circuit_properties(self, **kwargs): `'fourier_w_bias'`: Fourier circuit parameterization with a separate parameter for single-qubit terms init_type: `str` - Initialisation strategy for the QAOA circuit parameters. Allowed init_types: + Initialisation strategy for the FQAOA circuit parameters. Allowed init_types: `'rand'`: Randomly initialise circuit parameters `'ramp'`: Linear ramp from Hamiltonian initialisation of circuit parameters (inspired from Quantum Annealing) @@ -242,7 +274,7 @@ def set_circuit_properties(self, **kwargs): annealing_time: `float` Total time to run the FQAOA program in the Annealing parameterization (digitised annealing) linear_ramp_time: `float` - The slope(rate) of linear ramp initialisation of QAOA parameters. + The slope(rate) of linear ramp initialisation of FQAOA parameters. variational_params_dict: `dict` Dictionary object specifying the initial value of each circuit parameter for the chosen parameterization, if the `init_type` is selected as `'custom'`. @@ -280,9 +312,9 @@ def compile( Parameters ---------- problem: `QUBO` - portfolio optimisation problems converted to QUBO using penalty methods + QUBO problem to be solved by FQAOA n_fermions: `int` - a constraint value, budgets in portfolio optimization problem. + Number of fermions corresponding to the value of the constraint hopping: `float`, optional the coefficient of the fermionic mixer Hamiltonian verbose: bool @@ -343,10 +375,8 @@ def compile( # Backend configuration required for initial state preparation in FQAOA. lattice = self.circuit_properties.mixer_qubit_connectivity - # fermion orbitals - orbitals = get_fermi_orbitals(self.n_qubits, self.n_fermions, lattice, hopping) - # initial statevector or circuit + orbitals = get_fermi_orbitals(self.n_qubits, self.n_fermions, lattice, hopping) if self.device.device_name in 'vectorized': self.backend_properties.prepend_state = get_statevector(orbitals) else: @@ -619,7 +649,7 @@ def _serializable_dict( return serializable_dict - def _fermi_initial_circuit(self, orbitals: np.array, gate_applicator: object) -> object: + def _fermi_initial_circuit(self, orbitals: np.ndarray, gate_applicator: object) -> object: """ Constructs the initial quantum circuit for the FQAOA. @@ -629,7 +659,7 @@ def _fermi_initial_circuit(self, orbitals: np.array, gate_applicator: object) -> Parameters ---------- - orbitals : np.array + orbitals : numpy.ndarray A numpy array containing the orbital information needed to compute the Givens rotation angles. gate_applicator : object An object responsible for applying quantum gates to the circuit. @@ -722,42 +752,12 @@ def _decomposition_standard(self) -> List[Tuple]: class FermiBackendProperties(WorkflowProperties): """ - Choose the backend on which to run the QAOA circuits + Tunable backend properties for FQAOA circuit to be specified by the user. - Parameters - ---------- - device: DeviceBase - The device to use for the backend. - prepend_state: Union[openqaoa.basebackend.QuantumCircuitBase,numpy.ndarray(complex)] - The state prepended to the circuit. - append_state: Union[QuantumCircuitBase,numpy.ndarray(complex)] - The state appended to the circuit. - init_hadamard: bool - Whether to apply a Hadamard gate to the beginning of the - QAOA part of the circuit. - n_shots: int - The number of shots to be used for the shot-based computation. - cvar_alpha: float - The value of the CVaR parameter. - noise_model: NoiseModel - The `qiskit` noise model to be used for the shot-based simulator. - initial_qubit_mapping: Union[List[int], numpy.ndarray] - Mapping from physical to logical qubit indices, used to eventually - construct the quantum circuit. For example, for a system composed by 3 qubits - `qubit_layout=[1,3,2]`, maps `1<->0`, `3<->1`, `2<->2`, where the left hand side is the physical qubit - and the right hand side is the logical qubits - qiskit_simulation_method: str - Specify the simulation method to use with the `qiskit.AerSimulator` - qiskit_optimization_level: int, optional - Specify the qiskit.transpile optimization level. Choose from 0,1,2,3 - seed_simulator: int - Specify a seed for `qiskit` simulators - active_reset: bool - To use the active_reset functionality on Rigetti backends through QCS - rewiring: str - Specify the rewiring strategy for compilation for Rigetti QPUs through QCS - disable_qubit_rewiring: bool - enable/disable qubit rewiring when accessing QPUs via the AWS `braket` + The only difference with `BackendProperties` is that `init_hadamard` and `prepend_state` + are constrained in FQAOA. Because the initial state for FQAOA is specified within the `FQAOA.compile` method, + and therefore `init_hadamard` and `prepend_state` should not be set here. + Providing a value for this property will raise a ValueError. """ def __init__( @@ -784,8 +784,6 @@ def __init__( raise ValueError("In FQAOA, init_hadamard is not recognized.") if prepend_state is not None: raise ValueError("In FQAOA, prepend_state is not recognized.") - if append_state is not None: - raise ValueError("In FQAOA, append_state is not recognized.") self.init_hadamard = False self.prepend_state = None self.append_state = append_state @@ -802,9 +800,9 @@ def __init__( class FermiCircuitProperties(WorkflowProperties): """ - Tunable properties of the FQAOA circuit to be specified by the user + Tunable circuit properties of the FQAOA circuit to be specified by the user - The only difference with CircuitProperties is that mixer_hamiltonian is limited to "xy" + The only difference with `CircuitProperties` is that mixer_hamiltonian is limited to "xy" and mixer_qubit connetivity is limited to "cyclic" or "chain". """ From 9a6664278c58ab544e8c951849ec4b7eeed0e1cb Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Mon, 9 Sep 2024 10:35:29 +0900 Subject: [PATCH 17/26] Update notebook for consistency with website presentation --- examples/16_FQAOA_example.ipynb | 8 ++++---- examples/17_FQAOA_advanced_parameterization.ipynb | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/examples/16_FQAOA_example.ipynb b/examples/16_FQAOA_example.ipynb index 5fbc6ee94..b80367855 100644 --- a/examples/16_FQAOA_example.ipynb +++ b/examples/16_FQAOA_example.ipynb @@ -29,10 +29,10 @@ "\n", "- Broad Applicability: The Hamiltonian design guideline benefits QAOA and extends to other algorithms like Grover adaptive search and quantum phase estimation, making it a versatile tool for solving constrained combinatorial optimization problems.\n", "\n", - "This notebook describes the implementation of FQAOA, illustrates its application through various examples, and provides insight into FQAOA's superior performance in constrained combinatorial optimization tasks.\n", + "This notebook describes the implementation of FQAOA, illustrates its application through an example portfolio optimization problem, and provides insight into FQAOA's superior performance in constrained combinatorial optimization tasks.\n", "\n", "### Quadratic Constrained Binary Optimization Problems\n", - "The constrained combinatorial optimization problem for a quadratic binary cost function　$C_{\\boldsymbol x}$ can be written in the following form：\n", + "The constrained combinatorial optimization problem for a quadratic binary cost function $C_{\\boldsymbol x}$ can be written in the following form：\n", "$${\\boldsymbol x}^* = \\arg \\min_{\\boldsymbol x} C_{\\boldsymbol x}\\qquad {\\rm s.t.} \\quad\\sum_{i=1}^{N} x_i = M,$$\n", "with bit string ${\\boldsymbol x}\\in \\{0,1\\}^N$, where ${\\boldsymbol x}^*$ is the optimal solution.\n", "This problem can be replaced by the minimum eigenvalue problem in the following steps.\n", @@ -135,8 +135,8 @@ "source": [ "## Portfolio Optimization\n", "\n", - "In the following, the [portfolio optimization problem](https://en.wikipedia.org/wiki/Portfolio_optimization) is taken as a constrained quadratic optimisation problem.\n", - "Start by creating an instance of the portfolio optimisation problem, using the `random_instance` method of the `PortfolioOptimisation`." + "In the following, the [portfolio optimization problem](https://en.wikipedia.org/wiki/Portfolio_optimization) is taken as a constrained quadratic optimization problem.\n", + "Start by creating an instance of the portfolio optimization problem, using the `random_instance` method of the `PortfolioOptimization`." ] }, { diff --git a/examples/17_FQAOA_advanced_parameterization.ipynb b/examples/17_FQAOA_advanced_parameterization.ipynb index f54c272af..d2a04487c 100644 --- a/examples/17_FQAOA_advanced_parameterization.ipynb +++ b/examples/17_FQAOA_advanced_parameterization.ipynb @@ -36,7 +36,7 @@ "id": "bb6a05c9-82f7-431b-b60f-de61cd71d3cf", "metadata": {}, "source": [ - "Start by creating an instance of the portfolio optimisation problem, using the `random_instance` method of `the PortfolioOptimisation` class." + "Start by creating an instance of the portfolio optimization problem, using the `random_instance` method of the `PortfolioOptimization` class." ] }, { @@ -59,7 +59,7 @@ "source": [ "## Quantum Annealing with FQAOA\n", "\n", - "The framework of Fermionic QAOA (FQAOA) covers the Quantum Annealing (QA) framework [[1]](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071). In this note, we demonstrate that QA with FQAOA works for constrained combinatorial optimisation problems in practice and compare its performance with QA with conventional QAOA [[2]](https://arxiv.org/pdf/quant-ph/0001106)." + "The framework of Fermionic QAOA (FQAOA) covers the Quantum Annealing (QA) framework [[1]](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071). In this note, we demonstrate that QA with FQAOA works for constrained combinatorial optimization problems in practice and compare its performance with QA with conventional QAOA [[2]](https://arxiv.org/pdf/quant-ph/0001106)." ] }, { From 931ad4bb6b8d1a0c98b12c390ed1168727f0be9e Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Tue, 24 Sep 2024 14:32:56 +0900 Subject: [PATCH 18/26] Unified numpy.ndarray references to np.ndarray in docstrings and corrected incorrect usage of np.ndarray for np.array in the code. --- .../openqaoa/algorithms/fqaoa/fqaoa_utils.py | 10 +++++----- .../openqaoa/algorithms/fqaoa/fqaoa_workflow.py | 8 ++++---- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py index 94dfebcca..67d3c4915 100644 --- a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py +++ b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py @@ -16,7 +16,7 @@ def get_givens_rotation_angle(orbitals: np.ndarray) -> List[float]: Parameters ---------- - orbitals : numpy.ndarray + orbitals : np.ndarray A 2D NumPy array representing the matrix of orbitals. The matrix should have a shape of (n_fermions, n_qubits), where `n_fermions` is the number of rows and `n_qubits` is the number of columns. @@ -79,7 +79,7 @@ def get_statevector(orbitals: np.ndarray) -> np.ndarray: Returns ------- - numpy.ndarray + np.ndarray A 1D NumPy array of complex numbers representing the statevector of the quantum system. The length of this array is `2**n_qubits`, corresponding to all possible basis states. @@ -231,7 +231,7 @@ def get_fermi_orbitals( Returns ------- - numpy.ndarray + np.ndarray matrix representation of Fermionic orbitals. Notes @@ -297,7 +297,7 @@ def generate_random_portfolio_data( # Generate historical-like data for multiple assets over a number of days random_asset_factors = (1 - 2 * np.random.rand(num_assets)).reshape(-1, 1) - day_indices = np.ndarray([np.arange(num_days) for i in range(num_assets)]) + np.random.randint(10) + day_indices = np.array([np.arange(num_days) for i in range(num_assets)]) + np.random.randint(10) random_fluctuations = 1 - 2 * np.random.rand(num_assets, num_days) # The resulting matrix hist_exp represents the daily returns or price levels of the assets @@ -377,7 +377,7 @@ def _unitary_sparsification(orbitals: np.ndarray) -> np.ndarray: Returns ------- - numpy.ndarray + np.ndarray The modified matrix `orbitals` with its upper triangular elements set to zero. """ diff --git a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py index d814ef569..9a570f2a3 100644 --- a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py +++ b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_workflow.py @@ -187,11 +187,11 @@ def set_backend_properties(self, **kwargs): ---------- device: DeviceBase The device to use for the backend. - prepend_state: Union[openqaoa.basebackend.QuantumCircuitBase,numpy.ndarray(complex)] + prepend_state: Union[openqaoa.basebackend.QuantumCircuitBase,np.ndarray(complex)] The initial state for FQAOA is specified within the `FQAOA.compile` method, and therefore `prepend_state` should not be set here. Providing a value for this property will raise a ValueError. - append_state: Union[QuantumCircuitBase,numpy.ndarray(complex)] + append_state: Union[QuantumCircuitBase,np.ndarray(complex)] The state appended to the circuit. init_hadamard: bool Specifies whether to apply the Hadamard gate during initialization. @@ -202,7 +202,7 @@ def set_backend_properties(self, **kwargs): The value of the CVaR parameter. noise_model: NoiseModel The `qiskit` noise model to be used for the shot-based simulator. - initial_qubit_mapping: Union[List[int], numpy.ndarray] + initial_qubit_mapping: Union[List[int], np.ndarray] Mapping from physical to logical qubit indices, used to eventually construct the quantum circuit. For example, for a system composed by 3 qubits `qubit_layout=[1,3,2]`, maps `1<->0`, `3<->1`, `2<->2`, where the left hand side is the physical qubit @@ -659,7 +659,7 @@ def _fermi_initial_circuit(self, orbitals: np.ndarray, gate_applicator: object) Parameters ---------- - orbitals : numpy.ndarray + orbitals : np.ndarray A numpy array containing the orbital information needed to compute the Givens rotation angles. gate_applicator : object An object responsible for applying quantum gates to the circuit. From 2ad8d6b0d10395be9ff2918ac82fb83074071a13 Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Tue, 24 Sep 2024 16:03:20 +0900 Subject: [PATCH 19/26] refactor: remove redundant statevector variable and simplify code. prepare is_close_statevector for potential move to utilities.py --- src/openqaoa-core/openqaoa/utilities.py | 35 +++++++++++++++++++ src/openqaoa-core/tests/test_fqaoa.py | 42 +++-------------------- src/openqaoa-core/tests/test_workflows.py | 11 +++--- 3 files changed, 43 insertions(+), 45 deletions(-) diff --git a/src/openqaoa-core/openqaoa/utilities.py b/src/openqaoa-core/openqaoa/utilities.py index 145a3748a..0916fb7b5 100644 --- a/src/openqaoa-core/openqaoa/utilities.py +++ b/src/openqaoa-core/openqaoa/utilities.py @@ -1984,3 +1984,38 @@ def to_bin(number, n_qubits): ) / np.sqrt(len(wavefn_locs)) return wavefunction + +def is_close_statevector(statevector1, statevector2) -> bool: + """ + Checks if statevector1 can be expressed as e^(i*theta) * statevector2. + """ + + # Threshold for considering a value to be zero + tolerance = 1e-10 + + # Check if statevector1 is approximately zero where statevector2 is approximately zero + zero_mask_0 = np.isclose(statevector1, 0, atol=tolerance) + zero_mask_1 = np.isclose(statevector2, 0, atol=tolerance) + + if np.all(zero_mask_1 == zero_mask_0): + # Create a mask to avoid division by zero + non_zero_mask = ~np.isclose(statevector2, 0, atol=tolerance) + + # Compute the ratio with the mask applied + ratio = statevector1[non_zero_mask] / statevector2[non_zero_mask] + + # Verify if all ratios have the same phase angle + theta_calculated = np.angle(ratio) + theta_adjusted = (theta_calculated + np.pi) % (2 * np.pi) - np.pi + consistent_phase = np.allclose(theta_adjusted, theta_adjusted[0]) + + # Verify if all absolute values are same + absolute_ratio = np.abs(statevector1[non_zero_mask] / statevector2[non_zero_mask]) + consistent_magnitude = np.allclose(absolute_ratio, absolute_ratio[0]) + + if consistent_phase and consistent_magnitude: + return True + + return False + return False + diff --git a/src/openqaoa-core/tests/test_fqaoa.py b/src/openqaoa-core/tests/test_fqaoa.py index af72ce2e8..b4e7b9a06 100644 --- a/src/openqaoa-core/tests/test_fqaoa.py +++ b/src/openqaoa-core/tests/test_fqaoa.py @@ -2,6 +2,8 @@ import copy import numpy as np +from openqaoa.utilities import is_close_statevector + from openqaoa.algorithms.fqaoa.fqaoa_utils import ( get_analytical_fermi_orbitals, get_fermi_orbitals, @@ -50,8 +52,7 @@ def test_fermi_orbitals_equivalence_to_statevector(self): ]: analytical_fermi_orbitals = get_analytical_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) fermi_orbitals = get_fermi_orbitals(n_qubits, n_fermions, lattice, hopping) - statevector = [get_statevector(analytical_fermi_orbitals), get_statevector(fermi_orbitals)] - self.assertTrue(is_close_statevector(statevector[0], statevector[1]), + self.assertTrue(is_close_statevector(get_statevector(analytical_fermi_orbitals), get_statevector(fermi_orbitals)), "statevector[0] cannot be expressed as e^(i*theta) * statevector[1].") def test_givens_rotation_angle_length(self): @@ -119,8 +120,7 @@ def test_givens_rotation_to_statevector(self): temp = matrix[ik][icol - 1] matrix[ik][icol - 1] = temp * np.cos(-angle) - matrix[ik][icol] * np.sin(-angle) matrix[ik][icol] = temp * np.sin(-angle) + matrix[ik][icol] * np.cos(-angle) - statevector = [get_statevector(orbitals0), get_statevector(matrix)] - self.assertTrue(is_close_statevector(statevector[0], statevector[1]), + self.assertTrue(is_close_statevector(get_statevector(orbitals0), get_statevector(matrix)), "statevector[0] cannot be expressed as e^(i*theta) * statevector[1].") # exception handling @@ -166,39 +166,5 @@ def is_left_aligned_diagonal_matrix(matrix: np.ndarray) -> bool: return False return True -def is_close_statevector(statevector1, statevector2) -> bool: - """ - Checks if statevector1 can be expressed as e^(i*theta) * statevector2. - """ - - # Threshold for considering a value to be zero - tolerance = 1e-10 - - # Check if statevector1 is approximately zero where statevector2 is approximately zero - zero_mask_0 = np.isclose(statevector1, 0, atol=tolerance) - zero_mask_1 = np.isclose(statevector2, 0, atol=tolerance) - - if np.all(zero_mask_1 == zero_mask_0): - # Create a mask to avoid division by zero - non_zero_mask = ~np.isclose(statevector2, 0, atol=tolerance) - - # Compute the ratio with the mask applied - ratio = statevector1[non_zero_mask] / statevector2[non_zero_mask] - - # Verify if all ratios have the same phase angle - theta_calculated = np.angle(ratio) - theta_adjusted = (theta_calculated + np.pi) % (2 * np.pi) - np.pi - consistent_phase = np.allclose(theta_adjusted, theta_adjusted[0]) - - # Verify if all absolute values are same - absolute_ratio = np.abs(statevector1[non_zero_mask] / statevector2[non_zero_mask]) - consistent_magnitude = np.allclose(absolute_ratio, absolute_ratio[0]) - - if consistent_phase and consistent_magnitude: - return True - - return False - return False - if __name__ == '__main__': unittest.main() diff --git a/src/openqaoa-core/tests/test_workflows.py b/src/openqaoa-core/tests/test_workflows.py index bb595a419..12fe6b4b1 100644 --- a/src/openqaoa-core/tests/test_workflows.py +++ b/src/openqaoa-core/tests/test_workflows.py @@ -16,6 +16,7 @@ XY_mixer_hamiltonian, is_valid_uuid, ground_state_hamiltonian, + is_close_statevector, ) from openqaoa.algorithms.workflow_properties import ( BackendProperties, @@ -55,8 +56,6 @@ PARAMS_CLASSES_MAPPER, ) -from test_fqaoa import is_close_statevector - def _compare_qaoa_results(dict_old, dict_new): for key in dict_old.keys(): if key == "cost_hamiltonian": # CHECK WHAT DO WITH THIS @@ -2048,9 +2047,7 @@ def test_set_backend_properties_check_backend_vectorized(self): self.assertEqual(fqaoa.backend.init_hadamard, False) - statevector = [fqaoa.backend.prepend_state, initial_state] - is_close_statevector(statevector[0], statevector[1]) - self.assertTrue(is_close_statevector(statevector[0], statevector[1]), + self.assertTrue(is_close_statevector(fqaoa.backend.prepend_state, initial_state), f"statevector[0] cannot be expressed as e^(i*theta) * statevector[1].") self.assertEqual(fqaoa.backend.append_state, None) @@ -2085,8 +2082,8 @@ def test_set_backend_properties_check_backend_vectorized_w_custom(self): self.assertEqual(type(fqaoa.backend), QAOAvectorizedBackendSimulator) - statevector = [fqaoa.backend.prepend_state, initial_state] - is_close_statevector(statevector[0], statevector[1]) + self.assertTrue(is_close_statevector(fqaoa.backend.prepend_state, initial_state), + f"statevector[0] cannot be expressed as e^(i*theta) * statevector[1].") self.assertEqual(fqaoa.backend.cvar_alpha, 1) From db9001b91906931d5dc9ae4f6f428def9b562cb4 Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Wed, 25 Sep 2024 10:08:46 +0900 Subject: [PATCH 20/26] Switched from NumPy to SciPy for determinant calc --- src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py index 67d3c4915..4449cbf51 100644 --- a/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py +++ b/src/openqaoa-core/openqaoa/algorithms/fqaoa/fqaoa_utils.py @@ -109,7 +109,7 @@ def get_statevector(orbitals: np.ndarray) -> np.ndarray: for i, j in enumerate(indices): cof[:, i] = orbitals[:, j] # Calculate the determinant and store it in the statevector - statevector[inum] = np.linalg.det(cof) + statevector[inum] = linalg.det(cof) return statevector From 54284232059aef64506089acd956f5f39f4a2316 Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Wed, 25 Sep 2024 11:36:09 +0900 Subject: [PATCH 21/26] Renumber notebooks and made minor corrections to notebooks. --- docs/source/index.rst | 4 ++-- docs/source/notebooks | 1 + examples/15_Zero_Noise_Extrapolation.ipynb | 2 +- examples/16_FQAOA_example.ipynb | 4 ++-- examples/17_FQAOA_advanced_parameterization.ipynb | 7 +++---- 5 files changed, 9 insertions(+), 9 deletions(-) create mode 120000 docs/source/notebooks diff --git a/docs/source/index.rst b/docs/source/index.rst index 031d8d9d8..937d4e23b 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -315,10 +315,10 @@ Contents notebooks/12_testing_azure.ipynb notebooks/13_optimizers.ipynb notebooks/14_qaoa_benchmark.ipynb - notebooks/X_dumping_data.ipynb notebooks/15_Zero_Noise_Extrapolation.ipynb notebooks/16_FQAOA_example.ipynb - notebooks/17_FQAOA_advanced_parametrization.ipynb + notebooks/17_FQAOA_advanced_parameterization.ipynb + notebooks/X_dumping_data.ipynb Indices and tables ================== diff --git a/docs/source/notebooks b/docs/source/notebooks new file mode 120000 index 000000000..cefb44ef6 --- /dev/null +++ b/docs/source/notebooks @@ -0,0 +1 @@ +/Users/yoshioka/git/openqaoa/examples \ No newline at end of file diff --git a/examples/15_Zero_Noise_Extrapolation.ipynb b/examples/15_Zero_Noise_Extrapolation.ipynb index 25b938a4b..83d8c7dc7 100644 --- a/examples/15_Zero_Noise_Extrapolation.ipynb +++ b/examples/15_Zero_Noise_Extrapolation.ipynb @@ -5,7 +5,7 @@ "id": "9cef204d-fca2-4dbd-abbe-91fa08242061", "metadata": {}, "source": [ - "# Zero-Noise Extrapolation: an example workflow" + "# 15 - Zero-Noise Extrapolation: an example workflow" ] }, { diff --git a/examples/16_FQAOA_example.ipynb b/examples/16_FQAOA_example.ipynb index b80367855..d9057de45 100644 --- a/examples/16_FQAOA_example.ipynb +++ b/examples/16_FQAOA_example.ipynb @@ -97,7 +97,7 @@ "- mixing unitary $U(\\hat{\\cal H}_M, \\beta)$ on cyclic lattice:\n", "\\begin{eqnarray}\n", "U(\\hat{\\cal H}_M, \\beta) &\\sim&\n", - "\\exp\\left[i\\beta t(-1)^{M-1}\\left(\\hat{c}^{\\dagger}_{ND}\\hat{c}_{1}+\\hat{c}^{\\dagger}_{1}\\hat{c}_{ND}\\right)\\right]\n", + "\\exp\\left[i\\beta t(-1)^{M-1}\\left(\\hat{c}^{\\dagger}_{ND}\\hat{c}_{1}+\\hat{c}^{\\dagger}_{1}\\hat{c}_{ND}\\right)\\right]\\\\&&\\times\n", "\\prod_{i\\ {\\rm even}}\\exp\\left[i\\beta t\\left(\\hat{c}^{\\dagger}_i\\hat{c}_{i+1}+\\hat{c}^{\\dagger}_{i+1}\\hat{c}_{i}\\right)\\right]\n", "\\prod_{i\\ {\\rm odd}}\\exp\\left[i\\beta t\\left(\\hat{c}^{\\dagger}_i\\hat{c}_{i+1}+\\hat{c}^{\\dagger}_{i+1}\\hat{c}_{i}\\right)\\right],\n", "\\end{eqnarray}\n", @@ -419,7 +419,7 @@ "id": "8106c098-1fe7-43ad-b276-8aeeb57f0e7d", "metadata": {}, "source": [ - "# References\n", + "## References\n", "\n", "[1] T. Yoshioka, K. Sasada, Y. Nakano, and K. Fujii, [Phys. Rev. Research 5, 023071 (2023).](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071), [arXiv:2301.10756 [quant-ph]](https://arxiv.org/pdf/2301.10756).\\\n", "[2] T. Yoshioka, K. Sasada, Y. Nakano, and K. Fujii, [2023 IEEE International Conference on Quantum Computing and Engineering (QCE) 1, 300-306 (2023).](https://ieeexplore.ieee.org/document/10313662), [arXiv:2312.04710 [quant-ph]](https://arxiv.org/pdf/2312.04710).\\\n", diff --git a/examples/17_FQAOA_advanced_parameterization.ipynb b/examples/17_FQAOA_advanced_parameterization.ipynb index d2a04487c..de7aefff7 100644 --- a/examples/17_FQAOA_advanced_parameterization.ipynb +++ b/examples/17_FQAOA_advanced_parameterization.ipynb @@ -81,9 +81,8 @@ "$$|\\psi(T)\\rangle\\sim|\\psi_p({\\boldsymbol \\gamma}^{(0)}, {\\boldsymbol \\beta}^{(0)})\\rangle \n", "= \\left[\\prod_{j=1}^pU(\\hat{\\cal H}_M,\\beta_j^{(0)}){U}(\\hat{\\cal H}_C,\\gamma_j^{(0)})\\right]\\hat{U}_{\\rm init}|{\\rm vac}\\rangle,$$\n", "with\n", - "\\begin{eqnarray}\n", - " \\gamma_j^{(0)} &=& \\frac{2j-1}{2p}\\Delta t, \\\\\n", - " \\beta_j^{(0)} &=& \\left(1-\\frac{2j-1}{2p}\\right)\\Delta t,\n", + "$$\\gamma_j^{(0)} = \\frac{2j-1}{2p}\\Delta t,\\qquad\n", + "\\beta_j^{(0)} = \\left(1-\\frac{2j-1}{2p}\\right)\\Delta t$$,\n", "\\end{eqnarray}\n", "where $\\Delta t$ is the unit of discretized annealing time, as $T=p\\Delta t$.\n", "\n", @@ -290,7 +289,7 @@ "id": "8106c098-1fe7-43ad-b276-8aeeb57f0e7d", "metadata": {}, "source": [ - "# References\n", + "## References\n", "[1] T. Yoshioka, K. Sasada, Y. Nakano, and K. Fujii, [Phys. Rev. Research 5, 023071 (2023).](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.023071), [arXiv:2301.10756 [quant-ph]](https://arxiv.org/pdf/2301.10756).\\\n", "[2] E. Farhi, J. Goldston, S. Gutmann, and M. Sipser, [arXiv:quant-ph/0001106](https://arxiv.org/pdf/quant-ph/0001106).\\\n", "[3] L. Zhou, S. Wang, S. Choi, H. Pichler, and M. D. Lukin, [Phys. Rev. X 10, 021067 (2020).](https://journals.aps.org/prx/pdf/10.1103/PhysRevX.10.021067), [arXiv:1812.01041v2 [quant-ph]](https://arxiv.org/pdf/1812.01041)." From c19528bb80fd717fe789a92080c71e920d5f26be Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Wed, 25 Sep 2024 12:20:57 +0900 Subject: [PATCH 22/26] feat: Add type hints and consistency check for statevector sizes --- src/openqaoa-core/openqaoa/utilities.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/openqaoa-core/openqaoa/utilities.py b/src/openqaoa-core/openqaoa/utilities.py index 0916fb7b5..bfeee5a33 100644 --- a/src/openqaoa-core/openqaoa/utilities.py +++ b/src/openqaoa-core/openqaoa/utilities.py @@ -1985,11 +1985,16 @@ def to_bin(number, n_qubits): return wavefunction -def is_close_statevector(statevector1, statevector2) -> bool: +def is_close_statevector(statevector1: np.ndarray, statevector2: np.ndarray) -> bool: """ Checks if statevector1 can be expressed as e^(i*theta) * statevector2. + Both statevector1 and statevector2 must be numpy arrays of the same size. """ + # Check for size consistency + if statevector1.shape != statevector2.shape: + raise ValueError("The statevectors must have the same shape.") + # Threshold for considering a value to be zero tolerance = 1e-10 From 33e7290277d3f0873d4129fc1b1e507a3337f1a6 Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Thu, 26 Sep 2024 15:46:45 +0900 Subject: [PATCH 23/26] deleted: source/notebooks --- docs/source/notebooks | 1 - 1 file changed, 1 deletion(-) delete mode 120000 docs/source/notebooks diff --git a/docs/source/notebooks b/docs/source/notebooks deleted file mode 120000 index cefb44ef6..000000000 --- a/docs/source/notebooks +++ /dev/null @@ -1 +0,0 @@ -/Users/yoshioka/git/openqaoa/examples \ No newline at end of file From ac9ac272eaeb9b2cfdcdf50cea064b4e6cdaa67b Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Tue, 8 Oct 2024 08:24:40 +0900 Subject: [PATCH 24/26] Modify objective function to include risk factor --- src/openqaoa-core/openqaoa/problems/portfoliooptimization.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/openqaoa-core/openqaoa/problems/portfoliooptimization.py b/src/openqaoa-core/openqaoa/problems/portfoliooptimization.py index 41e9f27b7..9dac80a19 100644 --- a/src/openqaoa-core/openqaoa/problems/portfoliooptimization.py +++ b/src/openqaoa-core/openqaoa/problems/portfoliooptimization.py @@ -104,7 +104,7 @@ def docplex_model(self): # Specific the objective of the # portfolio optimization function - objective_function = -np.array(self.mu) @ x + x.T @ np.array(self.sigma) @ x + objective_function = -np.array(self.mu) @ x + self.risk_factor * x.T @ np.array(self.sigma) @ x # For this problem it aims to maximize the profit # of those assets minimizing the risk of the investment From 2603d99a9025c0ec51c411e90d79bab234d0e03a Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Tue, 8 Oct 2024 09:02:07 +0900 Subject: [PATCH 25/26] Update tests to account for risk factor in objective function --- .../tests/test_portfolio_optimization.py | 20 ++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/src/openqaoa-core/tests/test_portfolio_optimization.py b/src/openqaoa-core/tests/test_portfolio_optimization.py index b0116ada3..e7c4c138f 100644 --- a/src/openqaoa-core/tests/test_portfolio_optimization.py +++ b/src/openqaoa-core/tests/test_portfolio_optimization.py @@ -43,22 +43,28 @@ def test_portfoliooptimization_terms_weights_constant(self): """Test terms,weights,constant of QUBO generated by PortfolioOptimization class""" po_terms = [[0, 1], [0, 2], [1, 2], [0], [1], [2]] - po_weights = [0.505, 0.505, 0.505, 0.535, 0.535, 0.535] - po_constant = 0.8799999999999999 - mu = [0.1, 0.1, 0.1] - sigma = [[0.01, 0.01, 0.01], [0.01, 0.01, 0.01], [0.01, 0.01, 0.01]] + mu0 = 0.1 + sigma0 = 0.01 + mu = [mu0] * 3 + sigma = [[sigma0] * 3] * 3 risk_factor = 0.1 budget = 2 penalty = 1 + # w1, w2, po_constant are derived analytically + w1 = risk_factor*sigma0/2.0 + penalty/2.0 + w2 = (mu0 - risk_factor*sigma0*3)/2.0 + (penalty*budget - penalty*3/2.0) + po_weights = [w1]*3 + [w2]*3 + po_constant = (risk_factor*sigma0*12.0/4.0 - mu0*3/2.0) + (penalty*12/4.0 - penalty*budget*3 + penalty*budget**2) + qubo = PortfolioOptimization(mu, sigma, risk_factor, budget, penalty).qubo terms, weights = qubo.terms, qubo.weights constant = qubo.constant - - self.assertEqual(weights, po_weights) + for w, pw in zip(weights, po_weights): + self.assertAlmostEqual(w, pw, places=10) self.assertEqual(terms, po_terms) - self.assertEqual(po_constant, constant) + self.assertAlmostEqual(po_constant, constant, places=10) def test_portfoliooptimization_random_instance(self): """Test random instance method of PortfolioOptimization problem class""" From 3d6f495bcd57db646ded907ec66118bdbc93bce4 Mon Sep 17 00:00:00 2001 From: Takuya Yoshioka <88071178+yoshioka1128@users.noreply.github.com> Date: Tue, 8 Oct 2024 09:08:20 +0900 Subject: [PATCH 26/26] Adjust Jupyter notebook to reflect changes in risk factor implementation --- examples/16_FQAOA_example.ipynb | 66 +++++++++---------- .../17_FQAOA_advanced_parameterization.ipynb | 6 +- 2 files changed, 36 insertions(+), 36 deletions(-) diff --git a/examples/16_FQAOA_example.ipynb b/examples/16_FQAOA_example.ipynb index d9057de45..a2933c7cb 100644 --- a/examples/16_FQAOA_example.ipynb +++ b/examples/16_FQAOA_example.ipynb @@ -147,9 +147,9 @@ "outputs": [], "source": [ "# create a problem instance for portfolio optimization\n", - "num_assets = 8 # number of decision variables\n", - "budget = 4 # constraint on the sum of decision variables\n", - "problem = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget, penalty = None).qubo" + "num_assets = 4 # number of decision variables\n", + "budget = 2 # constraint on the sum of decision variables\n", + "problem = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget).qubo" ] }, { @@ -211,7 +211,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -273,12 +273,12 @@ " \n", " 0\n", " QAOA\n", - " 4.512233\n", + " -0.014343\n", " \n", " \n", " 1\n", " FQAOA\n", - " -0.482998\n", + " -1.675643\n", " \n", " \n", "\n", @@ -286,8 +286,8 @@ ], "text/plain": [ " Method Optimized Cost $\\langle C_{\\boldsymbol x} \\rangle$\n", - "0 QAOA 4.512233 \n", - "1 FQAOA -0.482998 " + "0 QAOA -0.014343 \n", + "1 FQAOA -1.675643 " ] }, "metadata": {}, @@ -348,38 +348,38 @@ " \n", " \n", " 0\n", - " 11100001\n", - " -1.371650\n", - " 0.005642\n", - " 0.009979\n", + " 1010\n", + " -1.797905\n", + " 0.144896\n", + " 0.904789\n", " \n", " \n", " 1\n", - " 11101000\n", - " -1.193696\n", - " 0.006019\n", - " 0.024488\n", + " 1100\n", + " -0.720493\n", + " 0.124931\n", + " 0.015386\n", " \n", " \n", " 2\n", - " 10101001\n", - " -1.080295\n", - " 0.006139\n", - " 0.192331\n", + " 0110\n", + " -0.602018\n", + " 0.122931\n", + " 0.033298\n", " \n", " \n", " 3\n", - " 10110001\n", - " -1.079240\n", - " 0.005780\n", - " 0.044356\n", + " 1001\n", + " -0.471908\n", + " 0.120777\n", + " 0.031587\n", " \n", " \n", " 4\n", - " 11100100\n", - " -0.949303\n", - " 0.006036\n", - " 0.020335\n", + " 0011\n", + " -0.362333\n", + " 0.119113\n", + " 0.012593\n", " \n", " \n", "\n", @@ -387,11 +387,11 @@ ], "text/plain": [ " Bitstring, $\\boldsymbol{x}$ Cost, $C_{\\boldsymbol x}$ QAOA FQAOA\n", - "0 11100001 -1.371650 0.005642 0.009979\n", - "1 11101000 -1.193696 0.006019 0.024488\n", - "2 10101001 -1.080295 0.006139 0.192331\n", - "3 10110001 -1.079240 0.005780 0.044356\n", - "4 11100100 -0.949303 0.006036 0.020335" + "0 1010 -1.797905 0.144896 0.904789\n", + "1 1100 -0.720493 0.124931 0.015386\n", + "2 0110 -0.602018 0.122931 0.033298\n", + "3 1001 -0.471908 0.120777 0.031587\n", + "4 0011 -0.362333 0.119113 0.012593" ] }, "metadata": {}, diff --git a/examples/17_FQAOA_advanced_parameterization.ipynb b/examples/17_FQAOA_advanced_parameterization.ipynb index de7aefff7..ebdff3e85 100644 --- a/examples/17_FQAOA_advanced_parameterization.ipynb +++ b/examples/17_FQAOA_advanced_parameterization.ipynb @@ -49,7 +49,7 @@ "# create a problem instance for portfolio optimization\n", "num_assets = 4 # number of assets\n", "budget = 2 # budget constraint value\n", - "problem = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget, penalty=None).qubo" + "problem = PortfolioOptimization.random_instance(num_assets=num_assets, budget=budget).qubo" ] }, { @@ -170,7 +170,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAHLCAYAAAAwZWlsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABqGUlEQVR4nO3dd1wT9/8H8NclJGHvLQgC7oF7z1actdUO99YOR1u77Pyq1F9r99A6qkVxoVartcNtHXUPtO6BouBANmETkvv9EYhEhoBABq/no/eA3H1y9/7koLy8+9ydIIqiCCIiIiITJzF0AURERERVgaGGiIiIzAJDDREREZkFhhoiIiIyCww1REREZBYYaoiIiMgsMNQQERGRWWCoISIiIrPAUENERERmgaGGiKgCwsPDIQgCbt26pZvXs2dP9OzZ02A1Pc6tW7cgCALCw8MNXQpRtWKoIaoiN27cwKuvvoqAgABYWlrC3t4eXbp0wY8//ojs7Owq315WVhbmzJmD/fv3V/m6q8Ply5chCAIsLS2Rmppq6HJM3pw5cyAIwmMnYw5bRFXNwtAFEJmDv//+Gy+99BIUCgXGjh2LZs2aIS8vD4cOHcJ7772HixcvYunSpVW6zaysLISGhgKASfzhWrNmDTw9PZGSkoJNmzZh8uTJhi6pyuzatavGt/n8888jKChI9zojIwNTpkzBkCFD8Pzzz+vme3h4wM/PD9nZ2ZDJZDVeJ1FNYqghekLR0dEYPnw4/Pz88M8//8DLy0u3bNq0aYiKisLff/9twAoNTxRFREREYOTIkYiOjsbatWvNKtTI5fIa32aLFi3QokUL3evExERMmTIFLVq0wOjRo4u1t7S0rMnyiAyCp5+IntBXX32FjIwMhIWF6QWaQkFBQXjzzTd1r/Pz8zF37lwEBgZCoVDA398fH330EXJzc/Xed+rUKfTt2xeurq6wsrJCvXr1MHHiRADaMRJubm4AgNDQUN2phjlz5pRY46lTpyAIAlauXFls2c6dOyEIAv766y8AQHp6OmbMmAF/f38oFAq4u7sjJCQEkZGRlfp8AODw4cO4desWhg8fjuHDh+PgwYO4c+dOsXb+/v545plncOjQIbRv3x6WlpYICAjAqlWr9NoVjms5fPgw3n77bbi5ucHGxgZDhgxBQkJCsfVu374d3bp1g42NDezs7DBw4EBcvHhRr825c+cwfvx43elDT09PTJw4EUlJSY/t36Njavbv3w9BEPDrr7/is88+g4+PDywtLfH0008jKiqq2PsXLlyIgIAAWFlZoX379vj333+rdJxOSWNqxo8fD1tbW8TExOCZZ56Bra0t6tSpg4ULFwIAzp8/j6eeego2Njbw8/NDREREsfWmpqZixowZ8PX1hUKhQFBQEL788ktoNJoqqZuoohhqiJ7Qn3/+iYCAAHTu3Llc7SdPnoxZs2ahdevW+P7779GjRw/MmzcPw4cP17WJj49Hnz59cOvWLXzwwQdYsGABRo0ahWPHjgEA3NzcsHjxYgDAkCFDsHr1aqxevVrvtENRbdu2RUBAAH799ddiyzZs2AAnJyf07dsXAPDaa69h8eLFeOGFF7Bo0SK8++67sLKywuXLlyv0uRS1du1aBAYGol27dhg0aBCsra2xbt26EttGRUXhxRdfREhICL799ls4OTlh/PjxxUIIALz++uv477//MHv2bEyZMgV//vknpk+frtdm9erVGDhwIGxtbfHll1/if//7Hy5duoSuXbvqDfbdvXs3bt68iQkTJmDBggUYPnw41q9fjwEDBkAUxUr1+4svvsCWLVvw7rvv4sMPP8SxY8cwatQovTaLFy/G9OnT4ePjg6+++grdunXD4MGDSwx9VU2tVqN///7w9fXFV199BX9/f0yfPh3h4eHo168f2rZtiy+//BJ2dnYYO3YsoqOjde/NyspCjx49sGbNGowdOxbz589Hly5d8OGHH+Ltt9+u9tqJSiQSUaWlpaWJAMTnnnuuXO3Pnj0rAhAnT56sN//dd98VAYj//POPKIqiuGXLFhGAePLkyVLXlZCQIAIQZ8+eXa5tf/jhh6JMJhOTk5N183Jzc0VHR0dx4sSJunkODg7itGnTyrXO8sjLyxNdXFzEjz/+WDdv5MiRYnBwcLG2fn5+IgDx4MGDunnx8fGiQqEQ33nnHd28FStWiADE3r17ixqNRjf/rbfeEqVSqZiamiqKoiimp6eLjo6O4ssvv6y3nbi4ONHBwUFvflZWVrF61q1bV6yewm1HR0fr5vXo0UPs0aOH7vW+fftEAGLjxo3F3Nxc3fwff/xRBCCeP39eFEXt5+/i4iK2a9dOVKlUunbh4eEiAL11Pk5ZPw/R0dEiAHHFihW6eePGjRMBiJ9//rluXkpKimhlZSUKgiCuX79eN//KlSvF1j137lzRxsZGvHbtmt62PvjgA1EqlYoxMTHlrp2oqvBIDdETUCqVAAA7O7tytd+2bRsAFPuX7DvvvAMAurE3jo6OAIC//voLKpWqKkrFsGHDoFKpsHnzZt28Xbt2ITU1FcOGDdPNc3R0xPHjx3Hv3r0q2e727duRlJSEESNG6OaNGDEC//33X4lHX5o0aYJu3brpXru5uaFhw4a4efNmsbavvPIKBEHQve7WrRvUajVu374NQHv0JTU1FSNGjEBiYqJukkql6NChA/bt26d7r5WVle77nJwcJCYmomPHjgBQ6VNvEyZM0BtvU9ivwr6cOnUKSUlJePnll2Fh8XCI46hRo+Dk5FSpbVZU0bFNjo6OaNiwIWxsbDB06FDd/IYNG8LR0VFvH2zcuBHdunWDk5OT3mfbu3dvqNVqHDx4sEbqJyqKoYboCdjb2wPQjkMpj9u3b0MikehdtQIAnp6ecHR01P0x7tGjB1544QWEhobC1dUVzz33HFasWFFs3E1FBAcHo1GjRtiwYYNu3oYNG+Dq6oqnnnpKN++rr77ChQsX4Ovri/bt22POnDklBoryWrNmDerVqweFQoGoqChERUUhMDAQ1tbWWLt2bbH2devWLTbPyckJKSkpj21bGAQK216/fh0A8NRTT8HNzU1v2rVrF+Lj43XvTU5OxptvvgkPDw9YWVnBzc0N9erVAwCkpaVVqu+Pq69wfz/682BhYQF/f/9KbbMiLC0tdWOzCjk4OMDHx0cvLBbOL7oPrl+/jh07dhT7XHv37g0Aep8tUU3h1U9ET8De3h7e3t64cOFChd736B+MkpZv2rQJx44dw59//omdO3di4sSJ+Pbbb3Hs2DHY2tpWqt5hw4bhs88+Q2JiIuzs7PDHH39gxIgRekcJhg4dim7dumHLli3YtWsXvv76a3z55ZfYvHkz+vfvX6HtKZVK/Pnnn8jJyUH9+vWLLY+IiMBnn32m93lIpdIS1yWWMK7lcW0LB6yuXr0anp6exdo92u8jR47gvffeQ8uWLWFrawuNRoN+/fpVeuBrRfpiCKXVV566NRoNQkJCMHPmzBLbNmjQ4MkLJKoghhqiJ/TMM89g6dKlOHr0KDp16lRmWz8/P2g0Gly/fh2NGzfWzX/w4AFSU1Ph5+en175jx47o2LEjPvvsM0RERGDUqFFYv349Jk+e/NhgVJJhw4YhNDQUv/32Gzw8PKBUKvUGKBfy8vLC1KlTMXXqVMTHx6N169b47LPPKhxqNm/ejJycHCxevBiurq56y65evYpPPvkEhw8fRteuXSvcl/IIDAwEALi7u+uOIJQkJSUFe/fuRWhoKGbNmqWbX3ikp7oU7u+oqCj06tVLNz8/Px+3bt3Su2Tb2AQGBiIjI6PMz5WopvH0E9ETmjlzJmxsbDB58mQ8ePCg2PIbN27gxx9/BAAMGDAAAPDDDz/otfnuu+8AAAMHDgSg/SP76L/mW7ZsCQC6U1DW1tYAUKG78zZu3BjNmzfHhg0bsGHDBnh5eaF79+665Wq1utipFnd3d3h7e+ud+kpMTMSVK1eQlZVV5vbWrFmDgIAAvPbaa3jxxRf1pnfffRe2trYlnoKqKn379oW9vT0+//zzEscmFV7+XXhk4tHP/NH9VNXatm0LFxcXLFu2DPn5+br5a9euLfF0mzEZOnQojh49ip07dxZblpqaqtcfoprCIzVETygwMBAREREYNmwYGjdurHdH4SNHjmDjxo0YP348AO24lnHjxmHp0qVITU1Fjx49cOLECaxcuRKDBw/W/Wt95cqVWLRoEYYMGYLAwECkp6dj2bJlsLe31wUjKysrNGnSBBs2bECDBg3g7OyMZs2aoVmzZmXWO2zYMMyaNQuWlpaYNGkSJJKH/7ZJT0+Hj48PXnzxRQQHB8PW1hZ79uzByZMn8e233+ra/fTTTwgNDcW+fftKvZfKvXv3sG/fPrzxxhslLlcoFOjbty82btyI+fPnV8vdbu3t7bF48WKMGTMGrVu3xvDhw+Hm5oaYmBj8/fff6NKlC3766SfY29uje/fu+Oqrr6BSqVCnTh3s2rVL7xLm6iCXyzFnzhy8/vrreOqppzB06FDcunUL4eHhCAwMrNTRuJry3nvv4Y8//sAzzzyD8ePHo02bNsjMzMT58+exadMm3Lp1q9jROaLqxlBDVAWeffZZnDt3Dl9//TW2bt2KxYsXQ6FQoEWLFvj222/x8ssv69r+8ssvCAgIQHh4OLZs2QJPT098+OGHmD17tq5NYdhZv349Hjx4AAcHB7Rv3x5r167VDV4tXNfrr7+Ot956C3l5eZg9e3a5Qs0nn3yCrKwsvaueAO3Rn6lTp2LXrl3YvHkzNBoNgoKCsGjRIkyZMqVCn8n69euh0WgwaNCgUtsMGjQIv/32G7Zv345nn322Qusvr5EjR8Lb2xtffPEFvv76a+Tm5qJOnTro1q0bJkyYoGsXERGB119/HQsXLoQoiujTpw+2b98Ob2/vaqmr0PTp0yGKIr799lu8++67CA4Oxh9//IE33njDqO8CbG1tjQMHDuDzzz/Hxo0bsWrVKtjb26NBgwYIDQ2Fg4ODoUukWkgQjWXEGhERAdAOwnVzc8Pzzz+PZcuWGbocIpPBMTVERAaUk5NTbCzPqlWrkJycbBIPKiUyJjxSQ0RkQPv378dbb72Fl156CS4uLoiMjERYWBgaN26M06dPG+RhmUSmimNqiIgMyN/fH76+vpg/fz6Sk5Ph7OyMsWPH4osvvmCgIaogHqkhIiIis8AxNURERGQWGGqIiIjILNSqMTUajQb37t2DnZ2dUd/UioiIiB4SRRHp6enw9vbWu2Hoo2pVqLl37x58fX0NXQYRERFVQmxsLHx8fEpdXqtCjZ2dHQDth2Jvb1/p9ahUKuzatQt9+vSpllu7GwP20Tywj6bP3PsHsI/mojr7qFQq4evrq/s7XppaFWoKTznZ29s/caixtraGvb29Wf9wso+mj300febeP4B9NBc10cfHDR3hQGEiIiIyCww1REREZBYYaoiIiMgs1KoxNURERKXRaDTIy8urlnWrVCpYWFggJycHarW6WrZhaE/SR5lMBqlU+sQ1MNQQEVGtl5eXh+joaGg0mmpZvyiK8PT0RGxsrNneJ+1J++jo6AhPT88n+nwYaoiIqFYTRRH379+HVCqFr69vmTd3qyyNRoOMjAzY2tpWy/qNQWX7KIoisrKyEB8fDwDw8vKqdA0MNUREVKvl5+cjKysL3t7esLa2rpZtFJ7asrS0NOtQU9k+WllZAQDi4+Ph7u5e6VNR5vnJEhERlVPh+A+5XG7gSmq3wkCpUqkqvQ6GGiIiIjz+xm5Uvari82eoISIiIrPAUENERERmgaGGiIjIhMXGxmLixInw9vaGXC6Hn58f3nzzTSQlJRVru27dOkilUkybNq3EdSUnJ2PGjBnw8/ODXC6Ht7c3Jk6ciJiYmBLbz5s3D1KpFF9//XWV9qmyGGqqwK3ETNxPyzZ0GUREVMvcvHkTbdu2xfXr17Fu3TpERUVhyZIl2Lt3Lzp16oTk5GS99mFhYZg5cybWrVuHnJwcvWXJycno2LEj9uzZgyVLliAqKgrr169HVFQU2rVrh5s3bxbb/vLlyzFz5kwsX768WvtZXrykuwp8u/sa/vzvHrwdLNHKzwmt6zqhdV1HNKvjAJmUuZGIiKrHtGnTIJfLsWvXLt1l0XXr1kWrVq0QGBiIjz/+GIsXLwYAREdH48iRI/jtt9+wb98+bN68GSNHjtSt6+OPP8a9e/cQFRUFT09P3bp27tyJ+vXrY9q0adi+fbuu/YEDB5CdnY1PP/0Uq1atwpEjR9CsWbMa7H1x/ItbBbLz8iERgHtpOfj73H3M/esShiw6grb/twfvbzqHf68nIF9dPXepJCKiqiWKIrLy8qt8ys5TP7aNKIrlrjM5ORk7d+7E1KlTdYGmkKenJ0aNGoUNGzbo1rlixQoMHDgQDg4OGD16NMLCwnTtNRoN1q9fj1GjRukCTSErKytMnToVO3fu1DvyExYWhhEjRkAmk2HEiBFGcbSGR2qqwC/j2iEzNx//3UnFmZhUnL6dgsiYFKRmqbDhVCw2nIqFs40c/Zp5YlSHumjq7WDokomIqBTZKjWazNppkG1f+rQvrOXl+9N8/fp1iKKIxo0bl7i8cePGSElJQUJCAlxdXREeHo4FCxYAAIYPH4533nkH0dHRqFevHhISEpCamlrmukRRRFRUFNq3bw+lUolNmzbh6NGjAIDRo0ejW7du+PTTT2Fvb1+JnlcNHqmpIjYKC3QOdMW0XkFYPr4dTn8SgoiXO2Bkh7pwtpEjOTMPEcdjMHD+IQz7+Sh2XoyDWlP+RE5ERFSSxx3dkcvl2L17NzIzMzFgwAAAgKurK0JCQoodXSnvkaJ169YhMDAQwcHBAICWLVvCz88PW7ZsqUQPqg6P1FQTqURA50BXdA50xafPNsXRm0n49dQdbDt/H8ejk3E8Ohm+zlaY3DUAw9v7QmHx5E8nJSKiJ2clk+LSp32rdJ0ajQbpynTY2duV+QgBK1n5/xYEBQVBEARcvnwZQ4YMKbb88uXLcHNzg6OjI8LCwpCcnKx3mkqj0eDcuXMIDQ3Vtbt8+XKJ27p8+TIEQUBQUBAA7amnixcvwsLCQm99a9asKfXKqprAUFMDLKQSdKvvhm713fDRgEZYdfQ2Io7HIDY5G7P/uIilB2/irZAGGNKqDqQS3tGSiMiQBEEo9ymg8tJoNMiXS2Ett6iyZz+5uLggJCQEixYtwltvvaUXWOLi4rB27VpMmzYNSUlJ2Lp1K9avX4+mTZvq2qjVanTt2hW7du1Cv379MHToUKxduxaffvqp3ria7OxsLFq0CH379oWzszPOnz+PU6dOYf/+/XB2dta1S0xMxFNPPYUrV66gSZMmVdLHiuLppxrm5WCF9/s1wrEPn8bc55rCw16Bu6nZeHfjf+j3w0HsuhhXoYFiRERUe/3000/Izc1F3759cfDgQcTGxmLHjh0ICQlBgwYNMGvWLKxevRouLi4YOnQomjVrppuCg4MxYMAA3YDhzz//HJ6enggJCcH27dsRGxuLgwcPom/fvlCpVFi4cCEA7VGa9u3bo3v37nrr6969O1q3bm3QAcMMNQZiJZdiTCd/HHivFz7s3wgOVjJcj8/AK6tPY9Qvx3EjIcPQJRIRkZGrX78+Tp48iYCAAAwdOhR+fn7o378/GjRogMOHD8PW1hbLly/HkCFDSny20gsvvIA//vgDiYmJcHFxwbFjx9CrVy+8+uqrCAwMxNChQxEYGKjbRl5eHtasWYMXXnihxHoGDRqE1atXP9FDKZ8EQ42BWcqkeLVHIA7O7IVpvQKhsJDgyI0k9P/hX3y3+xpyVGpDl0hEREbM398f4eHhiIuLg0ajwaxZs7Br1y6cO3cOAHDu3DndUZZHDR06FLm5uXB1dQWgHUA8f/58xMTEIC8vD3FxcVixYgXq1q0LQDvoODExEe+9916J63vzzTdx//59yGSyaujp4zHUGAkHKxne69sIu9/qgZ4N3ZCn1mD+3uvo98NBHLqeaOjyiIjIRISGhmL+/Pk4duwYNJradY80DhQ2MnVdrLFifDtsvxCH0D8v4lZSFkaHHce4Tn74oH9jWMl5lRQREZVtwoQJhi7BIHikxggJgoABzb2w5+0eGNvJDwCw8uhtDPrpEC7cTTNwdURERMaJocaI2VnK8OlzzbBqYnu42ykQFZ+BIYsOY/H+G7xxHxER0SMYakxA9wZu2DmjO/o19YRKLeLLHVcwdvlxJGXkGro0IiIio8FQYyKcbORYPLo1vnqxBazlUhyOSsIzCw7hbGyqoUsjIiIyCgw1JkQQBAxt64ut07ogwM0G99NyMHTJUaw5dps37CMiolqPocYE1feww9ZpXdCvqSfy1Bp88vsFvLvxHO9pQ0REtRpDjYmys5Rh8ejW+LB/I0gE4LfIOxj9C8fZEBFR7cVQY8IEQcCrPQKxelIH2Fta4NTtFAxZdARR8XzEAhER1T4MNWagS5ArNk/tgrrO1ohJzsLziw7jSBTvQkxEZM7Gjx8PQRCKTVFRUQCA2NhYTJw4Ed7e3pDL5fDz88Obb76JpKSkEte3bt06SKVSTJs2rcTlycnJmDFjBvz8/CCXy+Ht7Y2JEyciJiamxPbz5s2DVCrF119/XTUdLgeGGjMR5G6LLVM7o42fE5Q5+Ri7/AR+PRVr6LKIiKga9evXD/fv39eb6tWrh5s3b6Jt27a4fv061q1bh6ioKCxZsgR79+5Fp06dkJycXGxdYWFhmDlzJtatW4ecnBy9ZcnJyejYsSP27NmDJUuWICoqCuvXr0dUVBTatWuHmzdvFlvf8uXLMXPmzBp9ajdDjRlxsVVg7eQOeDbYG/kaETM3ncOSAzcMXRYREVUThUIBT09PvanwaItcLseuXbvQo0cP1K1bF/3798eePXtw9+5dfPzxx3rriY6OxpEjR/DBBx+gQYMG2Lx5s97yjz/+GPfu3cOePXvQv39/1K1bF927d8fOnTshk8mKHd05cOAAsrOz8emnn0KpVOLIkSPV/lkADDVmx1ImxY/DW+LVHgEAgC+2X8G8bZd5yTcRUXmJIpCXWfWTKuvxbarg/9XJycnYuXMnpk6dCisrK71lnp6eGDVqFDZs2KD3d2HFihUYOHAgHBwcMHr0aISFhemWaTQarF+/HqNGjYKnp6fe+qysrDB16lTs3LlT7+hPWFgYRowYAZlMhhEjRuitrzqZzAMtFy9ejMWLF+PWrVsAgKZNm2LWrFno37+/YQszQoIg4MP+jeFiI8fn267g54M3kZqlwmdDmsFCyhxLRFQmVRbwuXeVrlICwLE8DT+6B8htyr3ev/76C7a2trrX/fv3x7vvvgtRFNG4ceMS39O4cWOkpKQgISEB7u7u0Gg0CA8Px4IFCwAAw4cPxzvvvIPo6GjUq1cPCQkJSE1NLXN9oigiKioKjRo1glKpxKZNm3D06FEAwOjRo9GtWzf8+OOPerVWB5P5C+fj44MvvvgCp0+fxqlTp/DUU0/hueeew8WLFw1dmtF6pXsgvnqxBSQCsOFULKaujeS9bIiIzEivXr1w9uxZ3TR//nzdsscdoZfL5QCA3bt3IzMzEwMGDAAAuLq6IiQkpNhYmPIe8V+3bh0CAwMRHBwMAGjZsiX8/PywYcOGcverskzmSM2gQYP0Xn/22WdYvHgxjh07hqZNmxqoKuM3tK0vHKxkeH3dGey69ACvrj6Nn8e0gaVMaujSiIiMk8xae8SkCmk0GijT02FvZweJpIzjCTLrCq3XxsYGQUFBevPkcjkEQcDly5cxZMiQYu+5fPky3Nzc4OjoCEB7qig5OVnvVJVGo8G5c+cQGhqqa3v58uUSa7h8+TIEQdDVsWLFCly8eBEWFhZ661u+fDkmTZpUof5VlMmEmqLUajU2btyIzMxMdOrUqdR2ubm5yM19eDM6pVIJAFCpVFCpVJXefuF7n2QdNempBi4IG9Mar6yJxIFrCZgYfgJLRraClbz0YGNqfawM9tE8mHsfzb1/gOH7qFKpIIoiNBoNNBqNdqaFVdlvqiBRFAGZGqLMGhpBKKthucfViKKoq7soJycn9O7dG4sWLcKbb76pF1bi4uKwdu1aTJ06FRqNBklJSdi6dSsiIiL0DhCo1Wp0794dO3bsQL9+/fDSSy8hIiICc+bM0RtXk52djUWLFqFPnz5wcnLCsWPHcOrUKfzzzz9wdnbWtUtOTsZTTz2FS5cuoVGjRiX2R6PRQBRFqFQqSKX6f5/K+7MhiCY0gvT8+fPo1KkTcnJyYGtri4iICN3hspLMmTMHoaGhxeZHRETA2rpiadgc3FACP1+WIlcjoL69Bi830kDBAzZEVMtZWFjA09MTvr6+ulMypmDq1KlIS0vD2rVriy27ceMG+vbtiwYNGuDjjz+Gn58frly5glmzZsHCwgLbtm2Dra0tFi9ejPnz5+PSpUsQHglbEydO1I23SU5ORu/evWFpaYnQ0FA0btwYt2/fxmeffYaoqCjs2rUL/v7++PDDD3Hq1Cns3r27WE29e/dGp06dMHfu3BL7k5eXh9jYWMTFxSE/P19vWVZWFkaOHIm0tDTY29uX+pmYVKjJy8tDTEwM0tLSsGnTJvzyyy84cOAAmjRpUmL7ko7U+Pr6IjExscwP5XFUKhV2796NkJAQyGSySq/HECJjUjFx1Wlk5qrR1s8Ry8a0hq2i+AE7U+5jebGP5sHc+2ju/QMM38ecnBzExsbC398flpaW1bINURSRnp4OOzu7YuGhsiZMmIDU1FRs2bKlxOW3bt1CaGgodu7cifj4eIiiiCFDhmDVqlW6f9i3bNkSXbt2xU8//VTs/b/++ivGjRuH2NhYuLq6IjExEXPnzsXWrVsRFxcHZ2dn9OvXD3PmzEHdunWRm5sLHx8fzJw5E++9916x9X399df47rvvEBMTU+J+zsnJwa1bt+Dr61tsPyiVSri6uj421JjU6Se5XK47Z9emTRucPHkSP/74I37++ecS2ysUCigUimLzZTJZlfziVNV6alKHQDesmdQBY5efwKnbqXh59RmsnNgeNiUEG8A0+1hR7KN5MPc+mnv/AMP1Ua1WQxAESCSSsse7PIHCU0SF26kKK1euLHN5QECAXpvZs2fju+++w4ULF9CxY0cAwLlz50p9//DhwzF8+HDda3d3dyxYsEB3ldSjFAoFbty4AXt7+xL7+P777+P9998vdXsSiQSCIJT4c1DenwuTufqpJBqNRu9IDJVPq7pOWDv54fOiJq88xauiiIjMXGhoKObPn49jx44VG4djLkzmSM2HH36ou4theno6IiIisH//fuzcudPQpZmkFj6OWDWpA0b/chxHbybhldWnsWxsGygsOMiGiMhcTZgwwdAlVCuTOVITHx+PsWPHomHDhnj66adx8uRJ7Ny5EyEhIYYuzWS19HXEigntYCWT4uC1BExbewYqtXmmdyIiMn8mc6Smpm6xXNu083dG2Li2mBB+EnsuP8CM9Wfx4/CWhi6LiIiowkzmSA1Vn85Brvh5TBvIpAL+Pn8fH24+z2dFEVGtw//vGVZVfP4MNQQA6NnQHT+NbA2JAGw8fQdf7bpu6JKIiGpE4Y3e8vLyDFxJ7ZaVlQWg/Fc6lcRkTj9R9evb1BNfvNACMzedwy+HbuHZugJKv7UhEZF5sLCwgLW1NRISEiCTyarlsm6NRoO8vDzk5ORU22XjhlbZPoqiiKysLMTHx8PR0bHY3YQrgqGG9Axt64vUrDx8vu0K/oiRouPpOxjZsZ6hyyIiqjaCIMDLywvR0dG4fft2tWxDFEVkZ2fDysqqym6+Z2yetI+Ojo56j2CoDIYaKuaV7oFITM/B0n9v4ZOtl+Bsa4l+zbwMXRYRUbWRy+WoX79+tZ2CUqlUOHjwILp37262N1F8kj7KZLInOkJTiKGGSvRuSH2cu3oTx+IleGP9WayZpED7es6PfyMRkYmSSCTV9pgEqVSK/Px8WFpamm2oMYY+mueJPXpigiBgWIAGIY3dkZevweSVJ3H9QbqhyyIiIioVQw2VSiIA373UHG38nKDMyce45ScQl5Zj6LKIiIhKxFBDZbKUSfHL2LYIcLPBvbQcjF9xAsoclaHLIiIiKoahhh7LyUaOlRPaw81OgStx6Ziy5jTy8vk4BSIiMi4MNVQuvs7WWDG+HWzkUhyOSsL7v53j3TeJiMioMNRQuTWr44DFo9tAKhGw5cxd/LiXdx0mIiLjwVBDFdK9gRv+b3AzAMAPe65jc+QdA1dERESkxVBDFTaifV281iMQAPD+b+dw7GaSgSsiIiJiqKFKmtm3IQY294JKLeLV1adxIyHD0CUREVEtx1BDlSKRCPh2aDBa1XVEWrYKE1acRHImn3BLRESGw1BDlWYpk2LZ2LbwdbZCTHIWXlt9Grn5akOXRUREtRRDDT0RV1sFlo9rBzuFBU7cSsbHWy7wUm8iIjIIhhp6YvU97LBgZCtIBGDT6Tv4+eBNQ5dERES1EEMNVYmeDd0x65kmAIAvd1zBzotxBq6IiIhqG4YaqjLjOvtjdMe6EEVgxvqzuHgvzdAlERFRLcJQQ1VGEATMHtQU3eq7IlulxssrTyEhPdfQZRERUS3BUENVSiaV4KeRrRHgqn2q92treEUUERHVDIYaqnIOVjIsG9cWdpYWOH07BZ/wiigiIqoBDDVULQLdbLFwZGtIBGDj6TsIOxRt6JKIiMjMMdRQtenewA0fD9ReEfX5tss4cC3BwBUREZE5Y6ihajWxiz+GtvWBRgSmR0TyGVFERFRtGGqoWgmCgLmDm6GtnxPSc/Lx8qpTUOaoDF0WERGZIYYaqnYKCykWj24DLwdL3EzIxIz1Z6HWcOAwERFVLYYaqhFudgosHdMWCgsJ/rkSj293XTV0SUREZGYYaqjGNPdxwFcvtgAALNp/A3/+d8/AFRERkTlhqKEa9VzLOni1RwAA4L1N/+HCXT5KgYiIqgZDDdW4mX0boUcDN+SoNHh19WkkZfBRCkRE9OQYaqjGSSUC5o9ohXquNribmo1pEZFQqTWGLouIiEwcQw0ZhIOVDMvGtoGtwgLHbibjs78vG7okIiIycQw1ZDBB7nb4bmgwACD8yC1sPBVr4IqIiMiUMdSQQfVp6okZvesDAD7+/QLOxqYatiAiIjJZDDVkcG88VR99mnggL1+D11afRnx6jqFLIiIiE8RQQwYnkQj4blhL1He3RZwyB1PXRCIvnwOHiYioYhhqyCjYKiywdGxb2Fla4NTtFHz610VDl0RERCaGoYaMRj1XG8wf3gqCAKw5FoP1J2IMXRIREZkQhhoyKr0aueOdkAYAgFlbLyIyJsXAFRERkalgqCGjM7VnEPo29UCeumDgsJIDh4mI6PEYasjoSCQCvh2qHTgcn56L19ac5sBhIiJ6LIYaMkpFBw5HxqRizp8cOExERGVjqCGjVXTgcMTxGKzjwGEiIioDQw0ZNf2Bwxdw+jYHDhMRUckYasjoTesVhH5NPaFSi5iy5jQecOAwERGVgKGGjJ4gCPhmaLBu4PCUNaeRm682dFlERGRkGGrIJBQbOPzHJUOXRERERoahhkxG0YHD607EIOI4Bw4TEdFDDDVkUno1cse7fRoCAGb/cQGnbycbuCIiIjIWDDVkcqb2DMSA5tqBw6+tieTAYSIiAsBQQyZIEAR8/WIwGnrYIaHgjsMcOExERAw1ZJJsFBZYOrYN7C0tcCYmFbN+vwhRFA1dFhERGRBDDZksPxcbLBjZGhIB2HAqFms4cJiIqFZjqCGT1qOBG97v1wgAEPrHRRy/mWTgioiIyFAYasjkvdI9AM8GeyNfI2Lq2kjcS802dElERGQADDVk8gRBwJcvtEATL3skZebhldWnkKPiwGEiotqGoYbMgpVciqVj28DZRo4Ld5X4cPN5DhwmIqplGGrIbPg4WWPhyNaQSgRsOXMXv/wbbeiSiIioBjHUkFnpFOiC/w1sDACYt/0yDl5LMHBFRERUUxhqyOyM6+yPoW19oBGB6RGRiE7MNHRJRERUAxhqyOwIgoC5g5uhVV1HKHPy8fKqU0jPURm6LCIiqmYmE2rmzZuHdu3awc7ODu7u7hg8eDCuXr1q6LLISCkspPh5dBt42CsQFZ+BtzachUbDgcNERObMZELNgQMHMG3aNBw7dgy7d++GSqVCnz59kJnJUwtUMnd7Sywd0xZyCwn2XI7Hd7uvGbokIiKqRhaGLqC8duzYofc6PDwc7u7uOH36NLp3726gqsjYBfs64ovnm+PtX//DT/ui0NDTDoOCvQ1dFhERVQOTCTWPSktLAwA4OzuX2iY3Nxe5ubm610qlEgCgUqmgUlV+jEXhe59kHcbOnPo4qLkHLt71Q9jh23hv03/wdVSgqbe9WfWxNOyj6TP3/gHso7mozj6Wd52CaIJ3KNNoNHj22WeRmpqKQ4cOldpuzpw5CA0NLTY/IiIC1tbW1VkiGRmNCCy9IsHlVAkc5SLeaa6GvdzQVRERUXlkZWVh5MiRSEtLg729fantTDLUTJkyBdu3b8ehQ4fg4+NTaruSjtT4+voiMTGxzA/lcVQqFXbv3o2QkBDIZLJKr8eYmWMfldkqvLT0OG4mZqGVrwNWjGmJA/v2mlUfH2WO+/FR5t5Hc+8fwD6ai+rso1KphKur62NDjcmdfpo+fTr++usvHDx4sMxAAwAKhQIKhaLYfJlMViUfeFWtx5iZUx9dZDKEjW+P5346hDOxaQjdfh09FObVx9Kwj6bP3PsHsI/mojr6WN71mczVT6IoYvr06diyZQv++ecf1KtXz9AlkQmq52qDhaNaQyIAW87cw777gqFLIiKiKmIyoWbatGlYs2YNIiIiYGdnh7i4OMTFxSE7O9vQpZGJ6VbfDZ8MbAIA+OO2BPuu8lEKRETmwGRCzeLFi5GWloaePXvCy8tLN23YsMHQpZEJmtDFH8Pa1oEIAW9tPIercemGLomIiJ6QyYQaURRLnMaPH2/o0sgECYKAWQMbI8heRGauGpNWnkRSRu7j30hEREbLZEINUVWTW0gwsYEadZ2tcCclG6+tOY3cfLWhyyIiokpiqKFazUYG/DyqFewUFjh5KwWfbLkAE7zLARERgaGGCEHutlgwshUkArDx9B0sPXjT0CUREVElMNQQAejZ0B3/e0Z7RdQXO65g58U4A1dEREQVxVBDVGB8Z3+M7lgXogjMWH8WF+6mGbokIiKqAIYaogKCIGDOoKboVt8V2SrtFVFxaTmGLouIiMqJoYaoCAupBAtHtUZ9d1s8UOZi8qqTyMrLN3RZRERUDgw1RI+wt5QhbFw7ONvIceGuEm9tOAuNhldEEREZO4YaohLUdbHG0jFtIJdKsPPiA8zbftnQJRER0WMw1BCVoq2/M75+qQUAYNm/0Vh97LaBKyIiorIw1BCV4bmWdfBunwYAgNlbL2Df1XgDV0RERKVhqCF6jGm9gvBiGx9oRGD62khcuqc0dElERFQChhqixxAEAZ8PaY7OgS7IzFNjYjgv9SYiMkYMNUTlILeQYPHoNghyt0WcMgcTwk8iPUdl6LKIiKgIhhqicnKwkmHF+HZwtVXg8n0lpq6NhEqtMXRZRERUgKGGqAJ8na2xfHxbWMmk+Pd6Ij7afJ5P9SYiMhIMNUQV1MLHET8Vear3/L1Rhi6JiIjAUENUKU839sDcwc0AAN/vuYaNp2INXBERETHUEFXSqA5+mNIzEADw4ebzOHAtwcAVERHVbgw1RE/gvT4NMbilN/I1IqasOY3zd9IMXRIRUa3FUEP0BCQSAV+9GIwuQS7IylNjQvgJxCRlGbosIqJaiaGG6AnJLSRYMroNmnjZIzEjD+NWnEBSRq6hyyIiqnUYaoiqgJ2lDOET2qGOoxWiEzMxceUpZOXlG7osIqJahaGGqIq421ti1aT2cLSW4b/YVN6cj4iohjHUEFWhQDdbhI1rB0uZBPuvJmDmpnPQaHhzPiKimsBQQ1TF2vg5YdGo1pBKBGw5cxefb7vMuw4TEdUAhhqiavBUIw989UILAMAvh6Lx88GbBq6IiMj8MdQQVZMX2vjgowGNAABfbL/Cuw4TEVUzhhqiavRK90C80j0AAPDB5vPYdTHOwBUREZkvhhqiavZh/0Z4sY0P1BoR09edwZEbiYYuiYjILDHUEFUzQRDwxfPN0aeJB/LyNXh55Smcu5Nq6LKIiMwOQw1RDbCQSjB/RCt0DnRBZp4a45afQFR8uqHLIiIyKww1RDXEUibF0rFtEezjgJQsFcaEncCdFD4nioioqjDUENUgW4UFwie0R5C7Le6n5WD0L8cRn55j6LKIiMwCQw1RDXOykWPNpA7wdbbCraQsjPnlBFIy8wxdFhGRyWOoITIATwdLrJ3UEe52Clx9kI5xK04gPUdl6LKIiEwaQw2RgdR1scbayR3gbCPHuTtpmLTyFLLz1IYui4jIZDHUEBlQfQ87rJrYHnYKC5yITsZra04jN5/BhoioMhhqiAysWR0HrJjQDlYyKQ5cS8D0iDNQqTWGLouIyOQw1BAZgbb+zvhlXFvILSTYfekBZmw4i3wGGyKiCmGoITISXYJc8fPoNpBJBfx97j5mbjoHjUY0dFlERCaDoYbIiPRq5I4FI1pDKhGw+cxdfPz7BYgigw0RUXkw1BAZmX7NPPH9sJaQCMC6EzEI/fMSgw0RUTkw1BAZoWeDvfHVi8EQBCD8yC3M/esygw0R0WMw1BAZqRfb+GDekOYAgOWHozFv+xUGGyKiMjDUEBmx4e3r4rMhzQAASw/exJc7rjLYEBGVgqGGyMiN6uCHT59rCgBYcuAGvt11jcGGiKgElQo1n376KbKysorNz87OxqeffvrERRGRvrGd/DF7UBMAwE/7ovDdbgYbIqJHVSrUhIaGIiMjo9j8rKwshIaGPnFRRFTchC718MnAxgCABf9E8YgNEdEjKhVqRFGEIAjF5v/3339wdnZ+4qKIqGSTuwXgf888PGLzzS6OsSEiKmRRkcZOTk4QBAGCIKBBgwZ6wUatViMjIwOvvfZalRdJRA9N6loPAoBP/7qEhftuQCMCM/s2LPEfGkREtUmFQs0PP/wAURQxceJEhIaGwsHBQbdMLpfD398fnTp1qvIiiUjfxK71IAhA6J+XsHj/DWhEER/0a8RgQ0S1WoVCzbhx4wAA9erVQ5cuXWBhUaG3E1EVmtClHiSCgNl/XMTPB24iXy3ik4GNGWyIqNaq1JgaOzs7XL58Wfd669atGDx4MD766CPk5eVVWXFEVLZxnf0xd7D2PjZhh6Ix+4+LfAgmEdValQo1r776Kq5duwYAuHnzJoYNGwZra2ts3LgRM2fOrNICiahsYzr64csXmkMQgFVHb+Pj388z2BBRrVSpUHPt2jW0bNkSALBx40b06NEDERERCA8Px2+//VaV9RFROQxrVxffvhRc8BDMWMz87RzUDDZEVMtU+pJujUYDANizZw8GDBgAAPD19UViYmLVVUdE5fZ8ax98P6wlpBIBm07fwYwNZ6FSawxdFhFRjanUSN+2bdvi//7v/9C7d28cOHAAixcvBgBER0fDw8OjSgskovJ7rmUdyKUSvL7uDP787x6yc1Xo7/D49xERmYNKHan54YcfEBkZienTp+Pjjz9GUFAQAGDTpk3o3LlzlRZIRBXTv7kXlo5tA7mFBHuuJGDZFQmy89SGLouIqNpV6khNixYtcP78+WLzv/76a0il0icuioiezFONPLBifDtMXnkSV9KAyasjsXxCe9gqeBsGIjJfT/SU7tOnT2PNmjVYs2YNIiMjYWlpCZlMVlW1EdET6BLkiuXj2kAhFXHiVgpG/3IcaVkqQ5dFRFRtKvXPtvj4eAwbNgwHDhyAo6MjACA1NRW9evXC+vXr4ebmVpU1ElEltfVzwvQmaoRFWeFsbCqGLT2K1ZM6wM1OYejSiIiqXKWO1Lz++uvIyMjAxYsXkZycjOTkZFy4cAFKpRJvvPFGVddIRE+gri2wdlJbuNkpcCUuHUN/Poq7qdmGLouIqMpVKtTs2LEDixYtQuPGjXXzmjRpgoULF2L79u1VVhwRVY0GHnbY+Gon1HG0QnRiJl5afATRiZmGLouIqEpVKtRoNJoSx87IZDLd/Wuqw8GDBzFo0CB4e3tDEAT8/vvv1bYtInPj72qDTVM6IcDNBvfScvDSkqO4dE9p6LKIiKpMpULNU089hTfffBP37t3Tzbt79y7eeustPP3001VW3KMyMzMRHByMhQsXVts2iMyZl4MVfn21E5p42SMxIxfDlh7FqVvJhi6LiKhKVCrU/PTTT1AqlfD390dgYCACAwNRr149KJVKLFiwoKpr1Onfvz/+7//+D0OGDKm2bRCZO1dbBda90hHt/J2QnpOP0WHHse9qvKHLIiJ6YpW6+snX1xeRkZHYs2cPrly5AgBo3LgxevfuXaXFEVH1cLCSYdXEDpi69jT2XU3AyytP4duhwXiuZR1Dl0ZEVGkVCjX//PMPpk+fjmPHjsHe3h4hISEICQkBAKSlpaFp06ZYsmQJunXrVi3FVlRubi5yc3N1r5VK7fgBlUoFlary9+sofO+TrMPYsY/moaw+WgjAwhHBeH/zBfx5Lg4zNpxFSkYORnWoW9NlPhFz34/m3j+AfTQX1dnH8q5TEEWx3I/yffbZZ9GrVy+89dZbJS6fP38+9u3bhy1btpR3lZUmCAK2bNmCwYMHl9pmzpw5CA0NLTY/IiIC1tbW1VgdkenQiMDmWxL8G6c9G93PR4N+PhoIgoELIyIqkJWVhZEjRyItLQ329valtqtQqPHz88OOHTv0LuUu6sqVK+jTpw9iYmIqXnEFlSfUlHSkpvBJ4mV9KI+jUqmwe/duhISEmO0dlNlH81DePoqiiAX7bmDBvpsAgFHtffG/gY0glRh/sjH3/Wju/QPYR3NRnX1UKpVwdXV9bKip0OmnBw8elFmohYUFEhISKrLKaqVQKKBQFL9zqkwmq5IPvKrWY8zYR/NQnj6+07cx3O2tMOuPi1h7Ihap2fn4blgwFBam8Tw3c9+P5t4/gH00F9XRx/Kur0JXP9WpUwcXLlwodfm5c+fg5eVVkVVWSEZGBs6ePYuzZ88CAKKjo3H27NkaOTJEVBuM6eSPBSNaQSYV8Pf5+5gYfhIZufmGLouIqFwqFGoGDBiA//3vf8jJySm2LDs7G7Nnz8YzzzxTZcU96tSpU2jVqhVatWoFAHj77bfRqlUrzJo1q9q2SVTbPNPCGyvGt4eNXIrDUUkYvvQoEtJzH/9GIiIDq9Dpp08++QSbN29GgwYNMH36dDRs2BCAdizNwoULoVar8fHHH1dLoQDQs2dPVGAIEBFVUtf6rlj3SkdMWHESF+4q8cLiI1g5sT3qudoYujQiolJVKNR4eHjgyJEjmDJlCj788ENdwBAEAX379sXChQvh4eFRLYUSUc1q4eOI36Z0xtjlJxCTnIUXFx/B8vHtEOzraOjSiIhKVOE7Cvv5+WHbtm1ITEzE8ePHcezYMSQmJmLbtm2oV69eddRIRAbi72qD36Z0RrM69kjKzMOIZcewn3cfJiIjVanHJACAk5MT2rVrh/bt28PJyakqayIiI+Jmp8D6VzqhW31XZOWpMXnlKWw8FWvosoiIiql0qCGi2sNWYYGwce0wuKU38jUi3tt0DvP3XucYNyIyKgw1RFQucgsJvhvaElN6BgIAvtt9DR9tOY98tcbAlRERaTHUEFG5SSQC3u/XCHOfawqJAKw7EYtXVp9GVh7vZUNEhsdQQ0QVNqaTP5aMbgOFhQT/XInH8KXHEJ9e/P5VREQ1iaGGiCqlT1NPRLzcEU7WMpy7k4bnFx1BVHy6ocsiolqMoYaIKq2NnxM2T+0Cfxdr3EnJxvOLjuDYzSRDl0VEtRRDDRE9kXquNtg8tQta13WEMicfY8KO4/czdw1dFhHVQgw1RPTEnG3kiHi5I/o384RKLWLGhrNYwEu+iaiGMdQQUZWwlEmxcGRrvNxNe2fxb3dfw7sbzyEvn5d8E1HNYKghoiojkQj4eGAT/N/gZpBKBPwWeQdjlx9HWpbK0KURUS3AUENEVW50Rz+EjWsLW4UFjt1MxvOLDyMmKcvQZRGRmWOoIaJq0bOhOza+1gleDpa4kZCJwYsO49StZEOXRURmjKGGiKpNYy97/D6tC5rVsUdyZh5GLuOVUURUfRhqiKhaedhb4tdXO6FvUw/kqTWYseEsvtt1FRoNr4wioqrFUENE1c5aboHFo9rgtR7ah2HO/ycKb6w/gxyV2sCVEZE5YaghohohkQj4oH8jfPViC8ikAv46dx/Dfj6KeCWfGUVEVYOhhohq1NC2vlg9qQMcrWX4704anv3pMC7cTTN0WURkBhhqiKjGdQxwwdZpXRDkbos4ZQ5eXHIE28/fN3RZRGTiGGqIyCD8XGyweWpn9GjghhyVBlPWRmI+H61ARE+AoYaIDMbeUoawcW0xsYv20Qrf7b6G6evOIDuPA4iJqOIYaojIoCykEswa1ATznm8OmVTA3+fu48UlR3AvNdvQpRGRiWGoISKjMKJ9Xayd3BEuNnJcvKfEsz8dwunbvAMxEZUfQw0RGY329ZyxdXoXNPK0Q2JGHkYsPY4NJ2MMXRYRmQiGGiIyKj5O1tg8tTP6N/NEnlqD9387j9lbL0Cl1hi6NCIycgw1RGR0rOUWWDiyNd4OaQAAWHn0Nkb/chxJGbkGroyIjBlDDREZJYlEwBtP18eysW1hq7DA8ehk3qiPiMrEUENERi2kiQe2TO2Meq42uJuajReXHOGTvomoRAw1RGT06nvY4fdpXdCzofZGfTM2nMWnf17iOBsi0sNQQ0QmwcFKhrBx7TC9VxAAYPnhaI6zISI9DDVEZDKkEgHv9m2IJaPbwEYuxfHoZAxefAy30w1dGREZA4YaIjI5/Zp5Yuv0Lghws0GcMhc/XpRi3clYPjeKqJZjqCEikxTkboet07ogpLE71KKAWX9cxnubziFHxedGEdVWDDVEZLLsLGVYOCIYz9ZVQyIAm07fwfOLjiAmKcvQpRGRATDUEJFJEwQBT9cRET6+DVxs5Lh0X4lnFvyLPZceGLo0IqphDDVEZBY6Bbjgrze6oqWvI5Q5+Zi86hS+3HEF+bzsm6jWYKghIrPh5WCFX1/thPGd/QEAi/ffwKhfjiNemWPYwoioRjDUEJFZkVtIMOfZplg4srXusu8B8w/hyI1EQ5dGRNWMoYaIzNLAFl744/WuaOhhh8SMXIz+5Th+3HMdag0v+yYyVww1RGS2At1s8fu0Lhja1gcaEfh+zzWMXX4cCem8CzGROWKoISKzZiWX4qsXg/HtS8GwkklxOCoJ/X/8F0eieDqKyNww1BBRrfBCGx/8+XoXNPCwRWJGLkaFHce3u67y6igiM8JQQ0S1hvYuxF0xrK0vRBFY8E8Uhi89hrup2YYujYiqAEMNEdUqVnIpvnyxBeaPaAVbhQVO3U5B/x8OYseF+4YujYieEEMNEdVKzwZ7Y9sb3RBccLO+19ZE4qMt55Gdx2dHEZkqhhoiqrXqulhj46ud8GqPAABAxPEYPLPgX1y4m2bgyoioMhhqiKhWk1tI8GH/xlgzqQPc7RS4kZCJIYsOY+nBG9DwnjZEJoWhhogIQNf6rtgxozv6NPGASi3i821XMGb5cdxP4yBiIlPBUENEVMDZRo6fx7TBvOeb6+5p0/f7g9h69q6hSyOicmCoISIqQhAEjGhfF3+/0RXBPg5Q5uTjzfVnMT0iEqlZeYYuj4jKwFBDRFSCADdbbJrSGTN614dUIuCvc/fR94eDOHAtwdClEVEpGGqIiEohk0owo3cDbJ7SGQFuNnigzMW45Sfw4eZzSM9RGbo8InoEQw0R0WME+zri79e7YXxnfwDAuhOx6PfDvzjM50cRGRWGGiKicrCSSzHn2aZY93JH+Dpb4W5qNkb9chyf/H4eGbn5hi6PiMBQQ0RUIZ0CXbDjze4Y09EPALDmWAz6fs+xNkTGgKGGiKiCbBQWmDu4GdZO7qA7ajNu+Qm88+t/vEKKyIAYaoiIKqlLkCt2zuiOiV3qQRCA3yLvoPd3B7Ht/H2IIu9GTFTTGGqIiJ6AtdwCswY1wabXOiPI3RaJGbmYujYSL686hbupvBsxUU1iqCEiqgJt/Jzw9xtd8cZTQZBJBey5HI+Q7w7gl39vIl+tMXR5RLUCQw0RURVRWEjxdp+G2P5mN7T3d0ZWnhr/9/dlPPvTYZyNTTV0eURmj6GGiKiKBbnbYf0rHfHF881hb2mBS/eVGLLoMD7cfA7JmRxITFRdGGqIiKqBRCJgePu62PtOTzzfqg5EUXvTvqe+3Y+I4zHQaDiQmKiqmVyoWbhwIfz9/WFpaYkOHTrgxIkThi6JiKhUbnYKfDesJTa80hENPeyQmqXCR1vOY8iiw4iMSTF0eURmxaRCzYYNG/D2229j9uzZiIyMRHBwMPr27Yv4+HhDl0ZEVKYOAS74642u+N8zTWCrsMB/d9Lw/KIjeGvDWcSl5Ri6PCKzYFKh5rvvvsPLL7+MCRMmoEmTJliyZAmsra2xfPlyQ5dGRPRYMqkEk7rWwz/v9MBLbXwAAFvO3EWvb/bjp3+uI0elNnCFRKbNZEJNXl4eTp8+jd69e+vmSSQS9O7dG0ePHjVgZUREFeNub4mvXwrG1mld0LquI7JVanyz6xqe+mY/tpy5w/E2RJVkYegCyisxMRFqtRoeHh568z08PHDlypUS35Obm4vc3Fzda6VSCQBQqVRQqVSVrqXwvU+yDmPHPpoH9tG4NfG0wfrJ7fDnuTh8vesa7qXl4K0N/+GXf2/i/b4N0CnAxaT7V17so3mozj6Wd52CaCL38r537x7q1KmDI0eOoFOnTrr5M2fOxIEDB3D8+PFi75kzZw5CQ0OLzY+IiIC1tXW11ktEVBF5auBAnIA9dyXIUQsAgCaOGjxTV4M6NgYujsjAsrKyMHLkSKSlpcHe3r7UdiYTavLy8mBtbY1NmzZh8ODBuvnjxo1Damoqtm7dWuw9JR2p8fX1RWJiYpkfyuOoVCrs3r0bISEhkMlklV6PMWMfzQP7aHqSMvOwcN8NrDt5B/kFp6Fau2jwf8M7ob6ng4Grqx7mtg9Lwj4+GaVSCVdX18eGGpM5/SSXy9GmTRvs3btXF2o0Gg327t2L6dOnl/gehUIBhUJRbL5MJquSD7yq1mPM2EfzwD6aDk9HGeYOaYGJ3QLx3e5r+PO/e4hMkmDQ4hMY2tYHrz9VH96OVoYus1qYyz4sC/tY+XWWh8kMFAaAt99+G8uWLcPKlStx+fJlTJkyBZmZmZgwYYKhSyMiqlL1XG2wYEQrbJ3aEU0cNVBrRKw7EYseX+/Dx1vO82GZRCUwmSM1ADBs2DAkJCRg1qxZiIuLQ8uWLbFjx45ig4eJiMxFEy97vNpYA4+mHfDDPzdw7GYy1h6Pwa+nYvFSW19M7RkIHyeOESQCTCzUAMD06dNLPd1ERGSu2vg5Yf0rnXD8ZhJ+3HsdR24kIeJ4DH49GYvBrergtR6BCHK3NXSZRAZlcqGGiKg26xDggogAF5yITsaPe6/hcFQSNp2+g98i76BvE09M6RmIYF9HQ5dJZBAMNUREJqh9PWesndwRkTEpWLL/BnZdeoAdF+Ow42IcOgY4Y3LXADzVyB0SiWDoUolqDEMNEZEJa13XCUvHtsX1B+lYcuAmtp69i2M3k3HsZjLqudpgQhd/vNjGB9Zy/u+ezJ9JXf1EREQlq+9hh2+HBuPgzF54tUcA7C0tEJ2YiVlbL6Lj53sx969LiE7MNHSZRNWKoYaIyIx4O1rhw/6NcfTDpxH6bFP4u1hDmZOPsEPR6PXNfowJO45dF+OQr9YYulSiKsfjkUREZshGYYFxnf0xuqMfDl5LwOpjt7Hvajz+vZ6If68nwtPeEi+19cFLbXxR14WXhJN5YKghIjJjUomAXo3c0auRO2KTs3T3uIlT5mDBP1FY8E8UOge6YFg7X/Rp4gkrudTQJRNVGkMNEVEt4etsjQ/6N8JbIfWx+9IDbDgZi0NRiThyIwlHbiTBRi5Fv2ZeGNKqDjoFukDKK6fIxDDUEBHVMgoLKZ5p4Y1nWnjjTkqW7j43scnZ+C1S+727nQKDgr0xsIUXWvk6QhAYcMj4MdQQEdViPk7WmNG7Ad58uj4iY1KwOfIu/jp3H/HpuQg7FI2wQ9HwdrBEv2ZeGNjCE618nXjvGzJaDDVERARBENDGzxlt/Jwxe1BT7L8aj7/P38eeSw9wLy0Hyw9HY/nhaLjZKfB0I3f0buyBLkGuHINDRoWhhoiI9MgtJOjT1BN9mnoiR6XGwWsJ2Hb+PvZcjkdCei7Wn4zF+pOxsJRJ0DXIFT0auKFHA3deRUUGx1BDRESlspRJdQEnL1+D49FJ2HPpAfZcjsfd1GzsuRyPPZfjAVyEv4s1ejRwQ5cgV3So5wIHa5mhy6dahqGGiIjKRW4hQbf6buhW3w1znhVx6b4S+68m4OC1BJy+nYJbSVm4dfQ2Vh69DUEAmnjZo1OACzoFuqCNnxMcreWG7gKZOYYaIiKqMEEQ0NTbAU29HTCtVxDSc1Q4eiMJB68n4OiNJNxIyMTFe0pcvKfEL4eiAQBB7rZo6+eENn5OaFXXCQGuNhx0TFWKoYaIiJ6YnaVMd5oKAB4oc3DsZhKO3kjCiehk3EzMRFR8BqLiM7D+ZCwAwFZhgWZ17NHM2x75iQIaJ2YiyMOBQYcqjaGGiIiqnIe9JZ5rWQfPtawDAEjOzMPp2yk4dTsZkbdTcP5uGjJy83VPFAekCP/xMKxkUjTyskNjL3s08rRDkLst6rvbwdVWznvl0GMx1BARUbVztpEjpIkHQpp4AADy1Rpcj8/AuTupOBOTgsOXYhGfK0W2So0zMak4E5Oq935HaxmC3GxRz9UG/q42qOdqAz8Xa/i72MBGwT9lpMWfBCIiqnEWUgkae9mjsZc9nm/phW0Wt9CnbwjuKvNw6X46Lt9X4vqDdFyPz0BMchZSs1Q4dTsFp26nFFuXs40cPk5W8HGygq+TNTwdLOHlYAlPByt4OVjC1VbBRz7UEgw1RERkFCykEgS52yHI3Q7PBnvr5ueo1LiRoB2PcysxC7eSMhGdmIlbSZlIzVIhOTMPyZl5OHcnrcT1SgTA2UYBNzvt5Gorh6utAk7WcjjbyOBso4CTtQwOVtrJ3koGSxlvKmiKGGqIiMioWcqkuiutHqXMUeFuSjbupGQjNjkLd1Ky8UCZg3tp2YhLy0F8ei7UGhGJGblIzMjF5fvl26bCQgI7SxnsLC1gZ2kBW4UFbBQWsJZLYS0v/CqFpaxwksDSQvu93EKinaTarwoLCaBR40E2cDs5C9YKOSwkAiQSARYSAdKCSSJoJ+334BiiSmCoISIik2VvKYO9lwyNvexLXJ6v1iApMw8J6dpQk5Cei4SMXCRn5CE5Kw8pmXlIzlIhJTMPadkqKHNUEEUgN1+D3IIgVHUs8PnZQ+VuLQiARBAgQPsV2v+g/VYo+FrYVtB9j3JkoZKaFIaowiz16Lq18wsDF3QhrGid2VlSuDdNQacg93L3syox1BARkdmykErgYW8JD3vLcrXXaESk5+ZDma1Cek4+MnLzkZGrQkauGhk5+cjKy0dWnrpgykd2nho5+RrkqNTIUamRm69BXsGUm69GnloDVb4IlVqD7JxcCFILqNQi1KIItUYssxZRBNRiYZuy2xoPATkqjcG2zlBDRERUQCIRdGNrqpJKpcK2bdswYEBfyGTadYsFwaYw4GhEaL8WzBNFbRuNCIgo+Kqbr51XqDD7PBp9RLF8YUgXncSHc7TbeDhPU7ht6NegEbXLVKp8HD5yBM3rlHzUrCYw1BARERmAIAiwkApm84dYpVIh7gKqPBBWhMRgWyYiIiKqQgw1REREZBYYaoiIiMgsMNQQERGRWWCoISIiIrPAUENERERmgaGGiIiIzAJDDREREZkFhhoiIiIyCww1REREZBbM5e7M9DgnlgFJNwCFLSC3LfhqV/y13Eb7vaAwdMVEREQVwlBTW1z5C7i5v9zNZQAGSuSQXnMsEnzsigSgIq8Lg1BJIanwtdzm4fPsiYiIqgFDTW3RYhjg3QrIzQDyMoDc9IKvGUW+pmu/imoAgIUmD8iM105PTCgSdmxKCUmlBCNLB8DaGbByBqwcAYm0CuohIiJzw1BTW7QcWb52ogjk50CVmYr9u/5Cz85tIVPnlBKE0oG8zOKhqGibvAxA1AAQtcvz0p+wI4I22Fg5Pww6uq9OD19bu+gvk1k+4XaJiMjYMdSQPkEAZFaAjQWyFO6ARzNA9gSPkRdFQJWlDT8lhqISXudl6s/LSQWykoFcJQARyE7RTsk3yl+HzLpY8JFYOqHR/SRITsQCtm7Fw5GlA0+ZERGZEIYaql6CUHC6yQawdX+ydalV2jCTlQxkJ+t/zUoq+D6l+DJRrQ1WqixAeUe3OimAhgAQt7WU2qVlHw0q8aiQEyB9ghBIRESVxlBDpkMq0wajioQjUQRy0koMPOqMBMRcOQs/N1tIclL126iytGEoM0E7VYTCXhtwbNwf1mvr8fBr0fkyq4qtm4iISsVQQ+ZNKByD4wg46y/SqFQ4l7kNPgMGQPLoKTZVTkHISSrhyFBKCUeIkrXhCaL2NFmuEki59fj6FPZFwo5bkfBTJAjZuGuXWcir5jMhIjJTDDVEJZFZAjJvwN67/O/RqIHsVG3IyUzUXjWWUTg90B7xyXjwcJ4692EASop6/PqtnB8JPKUEIWsXXiFGRLUSQw1RVZFIARsX7eRav+y2hafFMgoumS8adnQhqMhrUa0NS9nJQMKVstctSABrV8DWA1IbN7RKzYXkn5OAvVeRU18FQcjKiYOhichsMNQQGULR02JuDcpuq9FoB0hnPHgYfkoLQllJ2kvoC+4vJAFQFwCOHi553ZKCcUqFR3zsPAA7b20Asis4UmXvzfBDRCaBoYbI2EkkD48AeTQpu606H8hKLAg8CchPu4drpw+ioa8zpFmJ+gEoJxXQqADlXe1UFgtLwM6zSODxAuzrFAk/XoCtJ8f9EJFBMdQQmROpRUH48AQAiCoVrt91QP2QAZA+Ohg6P/eRcT4PgPQ4QHkPSL8PKO8D6fe0R3/yc7QDnx83+NnGrSDwFBzh0QtB3tqvvP8PEVUThhqi2spCATj4aKey5Oc+DDnKu/qBp/Brehygznt4CXzcudLXJ7N+GHBK+2rroQ1oREQVwP9rEFHZLBSAk792Ko1Gox3ErLxbPPAo7xcEoXvaU16qLO3VXmVd8SVICsb4FA08j4zzsfPSPh+MiKgAQw0RPTmJBLBx1U5ewaW3y8t6GHBK/FoQgES19mv6feBeZOnrU9jDws4TnXLlkP69C3CsW3D0qQ7g4KsNP7zBIVGtwVBDRDVHbg24BGqn0mgK7uRcYuC5p32tvF/wAFUlhFwl3AHg7IWS12ftWiTk1Hkk9NTRjj/ifX2IzAJDDREZF4lUb7BzqXLTAeV95KfE4Pyh7Wjh7wJp+j3tKbC0O0DaXUCVqb0aLCsRuP9fyesRpNojOg4+RUKPj/5rXtJOZBIYaojINCnsADc7iI71EHM5E826PXKFl1jwRHddyCmYioYe5V3tqa60WO1UGpl1yUd5ioYfuXX195mIysRQQ0TmSRAKnqLuDHg2L7mNRq29lL1Y4CnyOjOhYHDzde1UGivnko/yFE62nryii6ia8TeMiGovifTh1VS+7Utuo8p5GHZKO+qTl/HwMRalXc4uSLRXbznUeRh6HOtqj/o4+mrnWTpUX1+JagGGGiKissgsyx7cXPgcL13IidWe2ir6WnkP0OQDyjvaKfZ4yetSOBQEnIKQ4+gLwdYbTpkx2nsBOdbRXmlGRCViqCEiehJFn+Pl2azkNhq19q7NutBT5GhPaox2XnYKkJsGPEgDHjy8kssCQHcAuPYpIJUXOaVVt1gAgr0PH1VBtRpDDRFRdZNItTcPtPcCfNqW3CY3oyDoxBYEHe33mpQY5D64Dsv8VAjqPCD5pnYqkaC9aszBp8hpLV/97y3tq62bRIbGUENEZAwUtoB7I+1UhFqlwq5t2zCgbwhk2QkFoafwaE9MwfcFr/NzHt608M7JUrZT5BRX4VgeB9+H43ts3HiKi0wWQw0RkSmQygAnP+1UElEEMhOLBJ07RQJQwZGfUk5x6W9H8fCy9WJHenx4iouMGkMNEZE5EATA1k071WlTcpvc9OJjeYoGoPT7gDq3nKe4fB854lNkjA+fyUUGwlBDRFRbKOwA98baqSRq1cPL1AtPaxUZ31P8FNeJktdj5aR/SuvR8GPtzDs0U7VgqCEiIi2prOwnsoui9maEhae0dMGnyNfcNO1pruyU0u/ZI7PWCzsSO2/4JCdBiHUGXOppn8DO53FRJTDUEBFR+QgCYOuunXxKOcWVk6Y/eFnvNFes9g7Oqiwg8ap2AiAF0AYAVi3RrkNiUfA8rrqPHOXxffgkdgtFTfSYTIzJhJrPPvsMf//9N86ePQu5XI7U1FRDl0RERI+ydAA8HUq/Z0/hHZqLhB1Nym0kR/8HF2kWhPSCGxWmxmin26Vsx9ajhLDDS9drO5MJNXl5eXjppZfQqVMnhIWFGbocIiKqjBLu0KxWqXB42zYMGDAAMqlEO15Hb0zPI6e48rO1R3wyHgB3T5W8HUsH7ZGewhsTFt6ksDD42Ljz0nUzZDKhJjQ0FAAQHh5u2EKIiKj6SKQP75qMTsWXiyKQlVQ86BQNQNkp2tNgOeeBB+dL2Y7s4aXrusBTMDnW5ZPXTZTJhJrKyM3NRW5uru61UqkEAKhUKqhUqkqvt/C9T7IOY8c+mgf20fSZe/+ASvRR7gC4OQBupZziyk0HlHchpMVCKBjbIyjvAGl3tV/T70PQqICUW9qpFKK1C2BfB6K9D0QHX8BB+z3sfSA6+AA2rtoHlVZHH01QdfaxvOsURFEUq3zr1Sg8PBwzZswo15iaOXPm6I7wFBUREQFrayZwIqLaSBDVsFSlwCovCdZ5SbDKS4KVKgnWeYm6eRaanMeuRy3IkC13RrbMBVlyF2QXTkVeayS8UWFVyMrKwsiRI5GWlgZ7+9LHSxk01HzwwQf48ssvy2xz+fJlNGr08LbhFQk1JR2p8fX1RWJiYpkfyuOoVCrs3r0bISEhkMlklV6PMWMfzQP7aPrMvX+AEfZRFIFcpfYIT1osBOVdQHkHQsGNC7VHe+Ig4PF/PkUbN4j2daCx88atFDXqNu8MiZOf9giQgy9g7WI29+ypzv2oVCrh6ur62FBj0NNP77zzDsaPH19mm4CAgEqvX6FQQKEoftmfTCarkg+8qtZjzNhH88A+mj5z7x9gZH2UuwJ2roBPy5KXq1WA8l6Rp67HFrlpYcFrVRaEzAQImQmQ3D+LIAD4Z6f+eiwsi4znKWF8j703ILOq5s5WrerYj+Vdn0FDjZubG9zc3AxZAhERUcWV51lc2Sm6sKNOvo2bZw8i0EUOSeFdmzPitHdoTorSTqWxdtGGG3sf7eBmve8LXvO+PQBMaKBwTEwMkpOTERMTA7VajbNnzwIAgoKCYGvL54wQEZEREQTt4yCsnQGvYGhUKlxKqAP/AQMgKTzqkJ/7yNGeR474KO9qb1SYlaSd4kq5kgvQPl3dviDk6MJOke/tvGrFg0hNJtTMmjULK1eu1L1u1aoVAGDfvn3o2bOngaoiIiKqJAsF4FxPO5VEFIGcVCDt7sNncinvFf8+P0f7+IrMBOD+2VI2VnA36BJDT8FpLjsvQGoysaBEJlN9eHg471FDRES1hyBoHw5q5VT6HZpFEchK1oYbXdi5W3AESDvAGcp7gDrv4Q0L70WWsj0JYOtZ8IiKImGn8HuHOto7ORvxc7lMJtQQERHRIwQBsHHRTl4tSm4jikBm4sOAUxh20grCj/IOoLwPaFRA+j3tVNqdmgWp9oiObmxPHd2AZsHaEwpVKiBqqq27j8NQQ0REZM4EAbB1007erUpuo9FoT189GnZ03xd8FdUFIehOsVVYAOgHIL+BLdDihWrtUmkYaoiIiGo7iQSw89BOdUp5ArtGrT19pbz3yGku7fdi2l3tc7vs69Rs7UUw1BAREdHjSaQFp5y8AZ+2xRbnq1TY/vef6O/VsuZrK8BHlBIREVGVEAWpQQcSM9QQERGRWWCoISIiIrPAUENERERmgaGGiIiIzAJDDREREZkFhhoiIiIyCww1REREZBYYaoiIiMgsMNQQERGRWWCoISIiIrPAUENERERmgaGGiIiIzAJDDREREZkFC0MXUJNEUQQAKJXKJ1qPSqVCVlYWlEolZDJZVZRmdNhH88A+mj5z7x/APpqL6uxj4d/twr/jpalVoSY9PR0A4Ovra+BKiIiIqKLS09Ph4OBQ6nJBfFzsMSMajQb37t2DnZ0dBEGo9HqUSiV8fX0RGxsLe3v7KqzQeLCP5oF9NH3m3j+AfTQX1dlHURSRnp4Ob29vSCSlj5ypVUdqJBIJfHx8qmx99vb2ZvvDWYh9NA/so+kz9/4B7KO5qK4+lnWEphAHChMREZFZYKghIiIis8BQUwkKhQKzZ8+GQqEwdCnVhn00D+yj6TP3/gHso7kwhj7WqoHCREREZL54pIaIiIjMAkMNERERmQWGGiIiIjILDDVERERkFhhqACxcuBD+/v6wtLREhw4dcOLEiTLbb9y4EY0aNYKlpSWaN2+Obdu26S0XRRGzZs2Cl5cXrKys0Lt3b1y/fr06u/BYFenjsmXL0K1bNzg5OcHJyQm9e/cu1n78+PEQBEFv6tevX3V3o0wV6WN4eHix+i0tLfXamPp+7NmzZ7E+CoKAgQMH6toY2348ePAgBg0aBG9vbwiCgN9///2x79m/fz9at24NhUKBoKAghIeHF2tT0d/x6lTRPm7evBkhISFwc3ODvb09OnXqhJ07d+q1mTNnTrH92KhRo2rsRdkq2sf9+/eX+LMaFxen185Y9mNF+1fS75kgCGjatKmujbHtw3nz5qFdu3aws7ODu7s7Bg8ejKtXrz72fYb++1jrQ82GDRvw9ttvY/bs2YiMjERwcDD69u2L+Pj4EtsfOXIEI0aMwKRJk3DmzBkMHjwYgwcPxoULF3RtvvrqK8yfPx9LlizB8ePHYWNjg759+yInJ6emuqWnon3cv38/RowYgX379uHo0aPw9fVFnz59cPfuXb12/fr1w/3793XTunXraqI7JapoHwHtXS+L1n/79m295aa+Hzdv3qzXvwsXLkAqleKll17Sa2dM+zEzMxPBwcFYuHBhudpHR0dj4MCB6NWrF86ePYsZM2Zg8uTJen/0K/OzUZ0q2seDBw8iJCQE27Ztw+nTp9GrVy8MGjQIZ86c0WvXtGlTvf146NCh6ii/XCrax0JXr17V64O7u7tumTHtx4r278cff9TrV2xsLJydnYv9LhrTPjxw4ACmTZuGY8eOYffu3VCpVOjTpw8yMzNLfY9R/H0Ua7n27duL06ZN071Wq9Wit7e3OG/evBLbDx06VBw4cKDevA4dOoivvvqqKIqiqNFoRE9PT/Hrr7/WLU9NTRUVCoW4bt26aujB41W0j4/Kz88X7ezsxJUrV+rmjRs3TnzuueequtRKq2gfV6xYITo4OJS6PnPcj99//71oZ2cnZmRk6OYZ234sCoC4ZcuWMtvMnDlTbNq0qd68YcOGiX379tW9ftLPrTqVp48ladKkiRgaGqp7PXv2bDE4OLjqCqtC5enjvn37RABiSkpKqW2MdT9WZh9u2bJFFARBvHXrlm6eMe9DURTF+Ph4EYB44MCBUtsYw9/HWn2kJi8vD6dPn0bv3r118yQSCXr37o2jR4+W+J6jR4/qtQeAvn376tpHR0cjLi5Or42DgwM6dOhQ6jqrU2X6+KisrCyoVCo4Ozvrzd+/fz/c3d3RsGFDTJkyBUlJSVVae3lVto8ZGRnw8/ODr68vnnvuOVy8eFG3zBz3Y1hYGIYPHw4bGxu9+cayHyvjcb+PVfG5GRuNRoP09PRiv4/Xr1+Ht7c3AgICMGrUKMTExBiowspr2bIlvLy8EBISgsOHD+vmm9t+DAsLQ+/eveHn56c335j3YVpaGgAU+7kryhj+PtbqUJOYmAi1Wg0PDw+9+R4eHsXO5RaKi4srs33h14qsszpVpo+Pev/99+Ht7a33g9ivXz+sWrUKe/fuxZdffokDBw6gf//+UKvVVVp/eVSmjw0bNsTy5cuxdetWrFmzBhqNBp07d8adO3cAmN9+PHHiBC5cuIDJkyfrzTem/VgZpf0+KpVKZGdnV8nPv7H55ptvkJGRgaFDh+rmdejQAeHh4dixYwcWL16M6OhodOvWDenp6QastPy8vLywZMkS/Pbbb/jtt9/g6+uLnj17IjIyEkDV/H/MWNy7dw/bt28v9rtozPtQo9FgxowZ6NKlC5o1a1ZqO2P4+1irntJNFffFF19g/fr12L9/v95A2uHDh+u+b968OVq0aIHAwEDs378fTz/9tCFKrZBOnTqhU6dOutedO3dG48aN8fPPP2Pu3LkGrKx6hIWFoXnz5mjfvr3efFPfj7VNREQEQkNDsXXrVr3xJv3799d936JFC3To0AF+fn749ddfMWnSJEOUWiENGzZEw4YNda87d+6MGzdu4Pvvv8fq1asNWFnVW7lyJRwdHTF48GC9+ca8D6dNm4YLFy4YdIxPedXqIzWurq6QSqV48OCB3vwHDx7A09OzxPd4enqW2b7wa0XWWZ0q08dC33zzDb744gvs2rULLVq0KLNtQEAAXF1dERUV9cQ1V9ST9LGQTCZDq1atdPWb037MzMzE+vXry/U/RkPux8oo7ffR3t4eVlZWVfKzYSzWr1+PyZMn49dffy12iP9Rjo6OaNCggcnsx5K0b99eV7+57EdRFLF8+XKMGTMGcrm8zLbGsg+nT5+Ov/76C/v27YOPj0+ZbY3h72OtDjVyuRxt2rTB3r17dfM0Gg327t2r96/4ojp16qTXHgB2796ta1+vXj14enrqtVEqlTh+/Hip66xOlekjoB2hPnfuXOzYsQNt27Z97Hbu3LmDpKQkeHl5VUndFVHZPhalVqtx/vx5Xf3msh8B7SWWubm5GD169GO3Y8j9WBmP+32sip8NY7Bu3TpMmDAB69at07skvzQZGRm4ceOGyezHkpw9e1ZXv7nsxwMHDiAqKqpc/8Aw9D4URRHTp0/Hli1b8M8//6BevXqPfY9R/H2skuHGJmz9+vWiQqEQw8PDxUuXLomvvPKK6OjoKMbFxYmiKIpjxowRP/jgA137w4cPixYWFuI333wjXr58WZw9e7Yok8nE8+fP69p88cUXoqOjo7h161bx3Llz4nPPPSfWq1dPzM7OrvH+iWLF+/jFF1+Icrlc3LRpk3j//n3dlJ6eLoqiKKanp4vvvvuuePToUTE6Olrcs2eP2Lp1a7F+/fpiTk6OSfQxNDRU3Llzp3jjxg3x9OnT4vDhw0VLS0vx4sWLujamvh8Lde3aVRw2bFix+ca4H9PT08UzZ86IZ86cEQGI3333nXjmzBnx9u3boiiK4gcffCCOGTNG1/7mzZuitbW1+N5774mXL18WFy5cKEqlUnHHjh26No/73GpaRfu4du1a0cLCQly4cKHe72NqaqquzTvvvCPu379fjI6OFg8fPiz27t1bdHV1FePj42u8f6JY8T5+//334u+//y5ev35dPH/+vPjmm2+KEolE3LNnj66NMe3Hivav0OjRo8UOHTqUuE5j24dTpkwRHRwcxP379+v93GVlZenaGOPfx1ofakRRFBcsWCDWrVtXlMvlYvv27cVjx47plvXo0UMcN26cXvtff/1VbNCggSiXy8WmTZuKf//9t95yjUYj/u9//xM9PDxEhUIhPv300+LVq1droiulqkgf/fz8RADFptmzZ4uiKIpZWVlinz59RDc3N1Emk4l+fn7iyy+/bLA/EoUq0scZM2bo2np4eIgDBgwQIyMj9dZn6vtRFEXxypUrIgBx165dxdZljPux8NLeR6fCfo0bN07s0aNHsfe0bNlSlMvlYkBAgLhixYpi6y3rc6tpFe1jjx49ymwvitrL2L28vES5XC7WqVNHHDZsmBgVFVWzHSuion388ssvxcDAQNHS0lJ0dnYWe/bsKf7zzz/F1mss+7EyP6epqamilZWVuHTp0hLXaWz7sKT+AdD7/TLGv49CQfFEREREJq1Wj6khIiIi88FQQ0RERGaBoYaIiIjMAkMNERERmQWGGiIiIjILDDVERERkFhhqiIiIyCww1BAREZFZYKghIiIis8BQQ0RGo2fPnpgxY0ax7w3NmGohotIx1BDVAkePHoVUKi3XE56NxebNmzF37txq3YYgCGVOc+bMqbFaHrVz587H1rdr164arYnI2FkYugAiqn5hYWF4/fXXERYWhnv37sHb29vQJT2Ws7NztW/j/v37uu83bNiAWbNm4erVq7p5tra2NVbLo7p3765XX7NmzTB16lRMnTpVN8/Nza3G6yIyZjxSQ2TmMjIysGHDBkyZMgUDBw5EeHi43vKePXvijTfewMyZM+Hs7AxPT0/dEYqKtNFoNJg3bx7q1asHKysrBAcHY9OmTbrlO3bsQNeuXeHo6AgXFxc888wzuHHjRql1P3rKpzw1pKenY9SoUbCxsYGXlxe+//77Mk8deXp66iYHBwcIgqA3rzDUlFTL66+/jhkzZsDJyQkeHh5YtmwZMjMzMWHCBNjZ2SEoKAjbt28v9+fzKCsrK10darUaSUlJ6Natm159Uqm01PcT1UYMNURm7tdff0WjRo3QsGFDjB49GsuXL4coinptVq5cCRsbGxw/fhxfffUVPv30U+zevbtCbebNm4dVq1ZhyZIluHjxIt566y2MHj0aBw4cAABkZmbi7bffxqlTp7B3715IJBIMGTIEGo2m3H15XA1vv/02Dh8+jD/++AO7d+/Gv//+i8jIyMp8bOWqxdXVFSdOnMDrr7+OKVOm4KWXXkLnzp0RGRmJPn36YMyYMcjKygLw+M+nLGfOnAEAtG7dulr6QmQ2RCIya507dxZ/+OEHURRFUaVSia6uruK+fft0y3v06CF27dpV7z3t2rUT33///XK3ycnJEa2trcUjR47otZk0aZI4YsSIEutKSEgQAYjnz5/X286bb75Z7Pvy1KBUKkWZTCZu3LhRtzw1NVW0trbWW09pVqxYITo4OJS47HG15OfnizY2NuKYMWN08+7fvy8CEI8ePVqpz6eo0NBQ0dfX97HtiGo7jqkhMmNXr17FiRMnsGXLFgCAhYUFhg0bhrCwMPTs2VPXrkWLFnrv8/LyQnx8vN68stpERUUhKysLISEhem3y8vLQqlUrAMD169cxa9YsHD9+HImJibojNDExMWjWrFm5+lNWDTdv3oRKpUL79u11yx0cHNCwYcNyrbuiitYilUrh4uKC5s2b6+Z5eHgAAOLj48v1+ZQlMjKSR2mIyoGhhsiMhYWFIT8/X29gsCiKUCgU+Omnn+Dg4AAAkMlkeu8TBKHYaaGy2mRkZAAA/v77b9SpU0evnUKhAAAMGjQIfn5+WLZsGby9vaHRaNCsWTPk5eWVuz/lqbOmlFRL0XmCIADQjqUpz+dTlsjISEyePPlJSyYyeww1RGYqPz8fq1atwrfffos+ffroLRs8eDDWrVuH1157rUq21aRJEygUCsTExKBHjx7FliclJeHq1atYtmwZunXrBgA4dOhQlWy7UEBAAGQyGU6ePIm6desCANLS0nDt2jV07969SrdVUY/7fMqSmJiI2NhYHqkhKgeGGiIz9ddffyElJQWTJk3SHZEp9MILLyAsLKzKQo2dnR3effddvPXWW9BoNOjatSvS0tJw+PBh2NvbY8yYMXBxccHSpUvh5eWFmJgYfPDBB1Wy7aI1jBs3Du+99x6cnZ3h7u6O2bNnQyKR6I6aGMrjPp9x48aV+t7Cgc4MNUSPx1BDZKbCwsLQu3fvYoEG0Iaar776CufOnauy7c2dOxdubm6YN28ebt68CUdHR7Ru3RofffQRJBIJ1q9fjzfeeAPNmjVDw4YNMX/+fL1xPVXhu+++w2uvvYZnnnkG9vb2mDlzJmJjY2FpaVml26mMsj6fspw5cwYeHh4mcW8hIkMTRPGRazuJiMxEZmYm6tSpg2+//RaTJk0ydDlEVM14pIaIzMaZM2dw5coVtG/fHmlpafj0008BAM8995yBKyOimsBQQ0Rm5ZtvvsHVq1chl8vRpk0b/Pvvv3B1dTV0WURUA3j6iYiIiMwCH5NAREREZoGhhoiIiMwCQw0RERGZBYYaIiIiMgsMNURERGQWGGqIiIjILDDUEBERkVlgqCEiIiKzwFBDREREZoGhhoiIiMwCQw0RERGZhf8HO+MzqU1wynkAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -262,7 +262,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAHHCAYAAACvJxw8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAACqLUlEQVR4nOzdd3xT1fvA8U+a7t3SDaWFsorsDSKgjDJUQBwIijgQEQRERVFBhoAoIm7ULwgqAj/cA4EyCsgGRfYUKAIto3SvNLm/P9KEpk3adNEmfd6vV14095577jlpoQ/nnPsclaIoCkIIIYQQwiyHqm6AEEIIIUR1JsGSEEIIIUQxJFgSQgghhCiGBEtCCCGEEMWQYEkIIYQQohgSLAkhhBBCFEOCJSGEEEKIYkiwJIQQQghRDAmWhBBCCCGKIcGSEEIAS5cuRaVSsW/fvhLL9ujRgx49elR+o4QQ1YIES0KIW+LMmTOMHj2a+vXr4+rqire3N7fffjvvv/8+WVlZFX6/zMxMpk+fTlxcXIXXXRY7duxg+vTpJCcnV3VThBCl5FjVDRBC2L/ff/+dBx54ABcXF0aMGEGzZs3Izc3lzz//5KWXXuLIkSN8/vnnFXrPzMxMZsyYAVDho0Dr168v9TU7duxgxowZjBw5El9f3wptjxCickmwJISoVGfPnmXo0KFERESwadMmQkNDjefGjh3L6dOn+f3336uwhaXn7Oxc1U0AQFEUsrOzcXNzq+qmCGHXZBpOCFGp3n77bdLT01m8eLFJoGTQoEEDJkyYYHyfl5fHrFmziIqKwsXFhcjISF599VVycnJMrtu3bx8xMTEEBATg5uZGvXr1eOKJJwA4d+4cgYGBAMyYMQOVSoVKpWL69OkltjcnJ4dJkyYRGBiIh4cHgwcP5urVqyZlzK1Z+vDDD7nttttwd3fHz8+Pdu3a8e233wIwffp0XnrpJQDq1atnbM+5c+dK1efIyEjuvvtu1q1bR7t27XBzc+Ozzz6je/futGzZ0mx/GjduTExMTIn9FkJYJiNLQohK9euvv1K/fn26dOliVfmnnnqKZcuWcf/99/PCCy+we/du5s6dy7Fjx/jxxx8BuHLlCn369CEwMJBXXnkFX19fzp07xw8//ABAYGAgn376KWPGjGHw4MHcd999ALRo0aLE+z/33HP4+fnxxhtvcO7cORYuXMi4ceNYtWqVxWu++OILxo8fz/3338+ECRPIzs7m4MGD7N69m2HDhnHfffdx8uRJVqxYwXvvvUdAQICxndb22eDEiRM8/PDDjB49mlGjRtG4cWM8PT0ZNWoUhw8fplmzZsaye/fu5eTJk7z++utWffZCCAsUIYSoJCkpKQqgDBw40KryBw4cUADlqaeeMjn+4osvKoCyadMmRVEU5ccff1QAZe/evRbrunr1qgIob7zxhlX3/vLLLxVA6dWrl6LT6YzHn3/+eUWtVivJycnGY927d1e6d+9ufD9w4EDltttuK7b+d955RwGUs2fPmhy3ts+KoigREREKoKxdu9akbHJysuLq6qq8/PLLJsfHjx+veHh4KOnp6cW2TQhRPJmGE0JUmtTUVAC8vLysKr9mzRoAJk2aZHL8hRdeADCubTIskP7tt9/QaDQV0VSjp59+GpVKZXx/xx13oNVqOX/+vMVrfH19+e+//9i7d2+p72dtnw3q1atXZFrNx8eHgQMHsmLFChRFAUCr1bJq1SoGDRqEh4dHqdslhLhJgiUhRKXx9vYGIC0tzary58+fx8HBgQYNGpgcDwkJwdfX1xiwdO/enSFDhjBjxgwCAgIYOHAgX375ZZE1PmVRt25dk/d+fn4A3Lhxw+I1L7/8Mp6ennTo0IGGDRsyduxYtm/fbtX9rO2zQb169czWM2LECOLj49m2bRsAGzZsIDExkUcffdSqdgghLJNgSQhRaby9vQkLC+Pw4cOluq7gyI6l89999x07d+5k3LhxXLx4kSeeeIK2bduSnp5eniajVqvNHjeM2JgTHR3NiRMnWLlyJV27duX777+na9euvPHGG1bft6Q+G1h68i0mJobg4GC++eYbAL755htCQkLo1auX1W0QQpgnwZIQolLdfffdnDlzhp07d5ZYNiIiAp1Ox6lTp0yOJyYmkpycTEREhMnxTp06MXv2bPbt28fy5cs5cuQIK1euBKwPPiqKh4cHDz30EF9++SXx8fEMGDCA2bNnk52dXWx7SttnS9RqNcOGDeO7777jxo0b/PTTTzz88MMWgz8hhPUkWBJCVKrJkyfj4eHBU089RWJiYpHzZ86c4f333wegf//+ACxcuNCkzIIFCwAYMGAAoJ8SKzzS06pVKwDjVJy7uzvALcmYff36dZP3zs7ONG3aFEVRjGuqDOuGCrfH2j5b49FHH+XGjRuMHj2a9PR0HnnkkdJ0QwhhgaQOEEJUqqioKL799lseeughoqOjTTJ479ixg9WrVzNy5EgAWrZsyWOPPcbnn39OcnIy3bt3Z8+ePSxbtoxBgwZx5513ArBs2TI++eQTBg8eTFRUFGlpaXzxxRd4e3sbgw83NzeaNm3KqlWraNSoEf7+/jRr1szk0fqK0qdPH0JCQrj99tsJDg7m2LFjfPTRRwwYMMC4uL1t27YAvPbaawwdOhQnJyfuueceq/tsjdatW9OsWTNWr15NdHQ0bdq0qfC+ClEjVe3DeEKImuLkyZPKqFGjlMjISMXZ2Vnx8vJSbr/9duXDDz9UsrOzjeU0Go0yY8YMpV69eoqTk5MSHh6uTJkyxaTMX3/9pTz88MNK3bp1FRcXFyUoKEi5++67lX379pncc8eOHUrbtm0VZ2fnEtMIGFIHFE5HsHnzZgVQNm/ebDxWOHXAZ599pnTr1k2pVauW4uLiokRFRSkvvfSSkpKSYlLXrFmzlNq1aysODg4maQSs6bOi6FMHDBgwoLiPWXn77bcVQJkzZ06x5YQQ1lMpSjGrFoUQQtiU999/n+eff55z584VebJPCFE2EiwJIYSdUBSFli1bUqtWLTZv3lzVzRHCbsiaJSGEsHEZGRn88ssvbN68mUOHDvHzzz9XdZOEsCsysiSEEDbu3Llz1KtXD19fX5599llmz55d1U0Swq5IsCSEEEIIUQzJsySEEEIIUQwJloQQQgghiiELvCuATqfj0qVLeHl53fItFoQQQghRNoqikJaWRlhYGA4OxYwfVVWCp7L66KOPlIiICMXFxUXp0KGDsnv3botlDUnmCr5cXFxMyuh0OmXq1KlKSEiI4urqqvTs2VM5efJkqdp04cKFIveRl7zkJS95yUtetvG6cOFCsb/nbWpkadWqVUyaNIlFixbRsWNHFi5cSExMDCdOnCAoKMjsNd7e3pw4ccL4vvDIz9tvv80HH3zAsmXLqFevHlOnTiUmJoajR4/i6upqVbsM2xlcuHABb29vi+U0Gg3r16+nT58+ODk5WVW3LatJ/ZW+2q+a1F/pq/2qSf0tTV9TU1MJDw83/h63xKaCpQULFjBq1Cgef/xxABYtWsTvv//OkiVLeOWVV8xeo1KpCAkJMXtOURQWLlzI66+/zsCBAwH46quvCA4O5qeffmLo0KFWtcsQgHl7e5cYLLm7u+Pt7W33P6xQs/orfbVfNam/0lf7VZP6W5a+lrSExmaCpdzcXPbv38+UKVOMxxwcHOjVqxc7d+60eF16ejoRERHodDratGnDnDlzuO222wA4e/YsCQkJ9OrVy1jex8eHjh07snPnTovBUk5OjnFnc9BHpqD/Bhl2GDfHcK64MvakJvVX+mq/alJ/pa/2qyb1tzR9tfbzsJlg6dq1a2i1WoKDg02OBwcHc/z4cbPXNG7cmCVLltCiRQtSUlKYP38+Xbp04ciRI9SpU4eEhARjHYXrNJwzZ+7cucyYMaPI8fXr1+Pu7l5iX2JjY0ssY09qUn+lr/arJvVX+mq/alJ/relrZmamVXXZTLBUFp07d6Zz587G9126dCE6OprPPvuMWbNmlbneKVOmMGnSJON7w5xnnz59SpyGi42NpXfv3nY/DAo1q7/SV/tVk/orfbVfNam/pemrYWaoJDYTLAUEBKBWq0lMTDQ5npiYaHFNUmFOTk60bt2a06dPAxivS0xMJDQ01KTOVq1aWazHxcUFFxcXs/Vb80NobTl7UZP6W137qtPpyM3NrZC6tFotjo6OaLXa4h+1tRM1qb/SV/tVk/pr6KtOp8PBwQG1Wm2xrLX/XttMsOTs7Ezbtm3ZuHEjgwYNAvS/ADZu3Mi4ceOsqkOr1XLo0CH69+8PQL169QgJCWHjxo3G4Cg1NZXdu3czZsyYyuiGELdcbm4uZ8+eRafTVUh9iqIQEhLChQsXakResZrUX+mr/apJ/TX0NT4+HpVKha+vLyEhIeXqt80ESwCTJk3iscceo127dnTo0IGFCxeSkZFhfDpuxIgR1K5dm7lz5wIwc+ZMOnXqRIMGDUhOTuadd97h/PnzPPXUU4B+9fvEiRN58803adiwoTF1QFhYmDEgE8KWKYrC5cuXUavVhIeHV8j/KHU6Henp6Xh6etr9/1ChZvVX+mq/alJ/DX318PAgOzubK1euAJjMIJWWTQVLDz30EFevXmXatGkkJCTQqlUr1q5da1ygHR8fb/JDcOPGDUaNGkVCQgJ+fn60bduWHTt20LRpU2OZyZMnk5GRwdNPP01ycjJdu3Zl7dq1VudYEqI6y8vLIzMzk7CwMKsePrCGYUrP1dXV7v/RhZrVX+mr/apJ/TX01c3NDQ8PDwCuXLlCUFBQsVNyxbGpYAlg3LhxFqfd4uLiTN6/9957vPfee8XWp1KpmDlzJjNnzqyoJgpRbWi1WkA/jS2EEDWR4T+KGo2mzMGSfYeXQgig5IRrQghhryri3z8JloQQQgghiiHBkhBCVDM9evRg4sSJxZZZunQpvr6+pa57+/btNG/eHCcnp0p/kCUuLg6VSkVycnKl3seenThxgpCQENLS0qq6KdVObm4ukZGR7Nu3r9LvJcGSEKLaGTlyJCqVqsjLkCMN9BtXP/HEE4SFheHs7ExERAQTJkzg+vXrZutcsWIFarWasWPHmj2flJTExIkTiYiIwNnZmbCwMJ544gni4+PNlp87dy5qtZp33nmn/B0u5IcffjBJnBsZGcnChQsrpO5JkybRqlUrzp49y9KlSyukTku6dOnC5cuX8fHxqdT72LMpU6bw3HPPlbjRa3lMnz6dJk2a4OHhgZ+fH7169WL37t2Vdj9r/fDDD/Tp04datWqhUqk4cOCAyXlnZ2defPFFXn755UpviwRL9kSbB3k5JZcTwgb07duXy5cvm7zq1asHwL///ku7du04deoUK1as4PTp0yxatIiNGzfSuXNnkpKSitS3ePFiJk+ezIoVK8jOzjY5l5SURKdOndiwYQOLFi3i9OnTrFy5ktOnT9OxY0fOnTtXpL4lS5YwefJklixZUuF99/f3r7RfjmfOnOGuu+6iTp06ZRqZspZGo8HZ2bnc+W0qKpmqNRRFIS8v75bdryTx8fH89ttvjBw5slLv06hRIz766CMOHTrEn3/+SWRkJH369OHq1auVet+SZGRk0LVrV+bNm2exzPDhw/nzzz85cuRI5TZGEeWWkpKiAEpKSkqx5XJzc5WffvpJyc3NrZyGfH6XosxvrCi5WZVTfylVen+rkera16ysLOXo0aNKVlbF/UxotVrlxo0bilarrbA6C3vssceUgQMHWjzft29fpU6dOkpmZqbJ8cuXLyvu7u7KM888Y3L833//Vdzc3JTk5GSlY8eOyvLly03OP/PMM4qHh4dy+fJlk+OZmZlK7dq1lZ49e5r0Ny4uTqldu7aSm5urhIWFKdu3by+2P0OGDFHGjh1rfD9hwgQFUI4dO6YoiqLk5OQo7u7uSmxsrKIoitK9e3dlwoQJxq8Bk5eiKMqXX36p+Pj4KGvXrlWaNGmieHh4KDExMcqlS5fMtuHs2bNF6vnyyy+N/Wnfvr3i7OysBAcHK5MnT1Y0Go3x2oiICOW9994zqa9ly5bKG2+8YXwPKJ988olyzz33KO7u7sobb7yhbN68WQGUGzduGMtt27ZN6dq1q+Lq6qrUqVNHee6555T09HSTe82cOVN59NFHFS8vL+Wxxx4z25/u3bsrY8eOVcaOHat4e3srtWrVUl5//XVFp9MZy3z11VdK27ZtFU9PTyU4OFh5+OGHlcTEREVR9D/Hv/76qwIoa9asUdq0aaM4OTkpmzdvVk6fPq3ce++9SlBQkOLh4aG0a9fO+L0p2M5Zs2Ypjz76qOLh4aHUrVtX+fnnn5UrV64o9957r+Lh4aE0b95c2bt3r/Gac+fOKXfffbfi6+uruLu7K02bNlV+//13s/1TFEV55513lHbt2pkcM3zff/zxR6VBgwaKi4uL0qdPHyU+Pt5iPYb+Wvv31vA7bcOGDSWWLdy28PBwxc3NTRk0aJAyf/58xcfHp1R1mGP42f3777/Nnr/zzjuV119/3fi+cF+L+3fQ2t/fMrJkL7R5cHEfpF2GS39VdWtENZeZm2fxla3Rllg2K1drddnM3Ir9n3pSUhLr1q3j2Wefxc3NzeRcSEgIw4cPZ9WqVSiKYjz+5ZdfMmDAAHx8fHjkkUdYvHix8ZxOp2PlypUMHz68yNZJbm5ujBkzhk2bNpmMVi1evJiHH34YJycnHn74YZP6zOnevbtJapMtW7YQEBBgPLZ37140Gg1dunQpcu0PP/xAnTp1mDlzpnGEzSAzM5P58+fz9ddfs3XrVuLj43nxxRfNtiE8PJzLly/j7e3NwoULuXz5Mg899BAXL16kf//+tG/fnr///pt3332XJUuW8OabbxbbJ3OmT5/O4MGDOXToEE888USR82fOnKFv374MGTKEgwcPsmrVKv78888i6WDmz59Py5Yt+fvvv5k6darF+y1btgxHR0f27NnD+++/z4IFC/jf//5nPK/RaJg1axb//PMPP/30E+fOnTM7SvPKK6/w1ltvcezYMVq0aEF6ejr9+/dn48aN/P333/Tt25d77rmnyJTse++9x+23387ff//NgAEDePTRRxkxYgSPPPIIf/31F1FRUYwYMcL4szh27FhycnLYunUrhw4dYt68eXh6elrs37Zt22jXrl2R45mZmcyePZuvvvqK7du3k5yczNChQ02u8/T0NHl5e3tTp04dvL298fT0ZPny5WbvmZuby+eff46Pjw8tW7a02LbCdu/ezZNPPsm4ceM4cOAAd955Z5GfIXPtKvyy1K7idOjQgW3btpX6utKwuTxLwoLcAov/gqKrrh3CJjSdts7iuTsbB/Ll4x2M79vO2kBWoaDIoGM9f1aNvrlZddd5m0nKKDptcu6tAaVu42+//Wbyi6Rfv36sXr2aU6dOoSgK0dHmf86jo6O5ceMGV69eJSgoCJ1Ox9KlS/nwww8BGDp0KC+88AJnz56lXr16XL16leTkZIv1NWnSBEVROH36NAEBAaSmpvLdd9+xc+dOAB555BHuuOMO3n//fYu/+Hr06MGECRO4evUqjo6OHD16lKlTpxIXF8czzzxDXFwc7du3N5s41N/fH7VajZeXV5FgTqPRsGjRIqKiogB9HjpLOePUarVxSszHx8dY1yeffEJ4eDgfffQRiqIQFhZGcnIyr7zyCtOmTStVAsNhw4YZd1QA/XRpQXPnzmX48OHGxesNGzbkgw8+oHv37nz66afGZMB33XUXL7zwQon3Cw8P57333kOlUtG4cWMOHTrEe++9x6hRowBMArb69evzwQcf0L59e9LT000+65kzZ9K7d2/je39/f5NAYdasWfz444/88ssvJoFd//79GT16NADTpk3j008/pX379jzwwAMAvPzyy3Tu3Nm4h2l8fDxDhgyhefPmxjYV5/z582aDJY1Gw0cffUTHjh0BfdAYHR3Nnj176NChA+3atSuyvqdwBm9DMmeD3377jaFDh5KZmUloaCixsbEEBAQU276C3n//ffr27cvkyZMB/dTejh07WLt2rbGMuXYVVrhd1ggLC+P8+fOlvq40JFiyFznp+j/VzuDmV7VtEaIC3HnnnXz66afG94ZMvAYFR47MMSTijI2NJSMjw7gnZEBAAL1792bJkiUmi6hLqs9gxYoVREVFGX+ZtmrVioiICFatWsWTTz5p9ppmzZrh7+/Pli1bcHZ2pnXr1tx99918/PHHgH6kqUePHlbdvyB3d3djoAT67RwMWztY69ixY3Tu3BmVSmX8DLp06UJ6ejr//fcfdevWtbouc7/YC/rnn384ePCgyeiBoijodDrOnj1rDFhLqsegU6dOJuuhOnfuzLvvvotWq0WtVrN//36mT5/OP//8w40bN4z7I8bHx9OkSROL7U5PT2f69On8/vvvXL58mby8PLKysoqMLLVo0cL4teGXvCEQKnjsypUrhISEMH78eMaMGcP69evp1asXQ4YMMamjsKysLLO7STg6OtK+fXvj+yZNmuDr68uxY8fo0KEDbm5uNGjQwOQanU5Hamoq3t7eZgPgO++8kwMHDnDt2jW++OILHnzwQXbv3k1QUJDF9hV07NgxBg8ebHKsc+fOJsGSuXZVBDc3NzIzMyu83oIkWLIXufnBkrPlIV0hDI7OjLF4zqHQYtz9U3uZvNfpdKSlpuHl7YVjoWy4f758Z4W10cPDw+w/rA0aNEClUpn9xxn0/2gHBgYaFy8vXryYpKQkkyk7nU7HwYMHmTFjhrHssWPHzLbj+PHjqFQqY1sWL17MkSNHcHR0NKlvyZIlFoMllUpFt27diIuLw8XFhR49etCiRQtycnI4fPgwO3bssDh9VpzCO6YXDHgqkoODQ5F6NRpNkXKFA9rC0tPTGT16NOPHjy9yrmBQVlI91sjIyCAmJoaYmBiWL19OYGAg8fHxxMTEFFk0Xvh+L774IrGxscyfP58GDRrg5ubG/fffX+S6gp+/IWgzd8wQpD311FPExMTw+++/s379eubOncu7777Lc889Z7YPAQEB3Lhxo9R937ZtG/369Su2zGeffcbw4cON7w1/3xo0aECnTp1o2LAhixcvZsqUKaW+f0W2yxpJSUkEBgaWp2klkmDJXuTkT8NlJcGZzRBVcb+0hP1xd7b+r37hsjqdjjxnNe7OjkX+h1qaesuqVq1a9O7dm08++YTnn3/eJAhKSEhg+fLlxvQA169f5+eff2blypXcdtttxnJarZauXbuyfv16+vbty4MPPsjy5cuZOXOmyVRXVlYWn376KXfddRf+/v4cOnSIffv2ERcXh7+/v7FcUlISPXr04Pjx4yYjFgV1796dL774AhcXF2bPno2DgwPdunXjnXfeIScnh9tvv91in52dnY1b11S06Ohovv/+e5NgaMeOHXh5eVGnTh0AAgMDTdZKpaamcvbs2VLfq02bNhw9erTCRhcKP96+a9cuGjZsiFqt5vjx41y/fp233nqL8PBwAKvz8Wzfvp2RI0cag/H09HSzT0SWRXh4OM888wzPPPMMU6ZM4YsvvrAYLLVu3ZqjR48WOZ6Xl8e+ffvo0EE/XX7ixAmTqeSyTMMVptPpyMmx/unq6Ohos9+PgiprGu7w4cO0bt261NeVhizwthc5BdYsHf6u6tohxC3w0UcfkZOTQ0xMDFu3buXChQusXbuW3r1706hRI6ZNmwbA119/Ta1atXjwwQdp1qyZ8dWyZUv69+9vXJg9Z84cQkJC6N27N3/88QcXLlxg69atxMTEoNFomD9/PqAfVerQoQPdunUzqa9bt260b9++2IXePXr04OjRoxw5coSuXbsajy1fvpx27doVO5oSGRnJ1q1buXjxIteuXauojxGAZ599lgsXLvDcc89x/Phx1qxZw/Tp05k0aZIxGL7rrrv4+uuv2bZtG4cOHeKxxx4r0x5bL7/8Mjt27DAuAj516hQ///yzxf0+SxIfH8+kSZM4ceIEK1as4MMPP2TChAmAfqTK2dmZDz/8kH///ZdffvnFZNq1OA0bNuSHH37gwIED/PPPPwwbNsw4OlQeEydOZN26dZw9e5a//vqLzZs3W1wrBxATE8POnTuLBMpOTk4899xz7N69m/379zNy5Eg6depkDJ4M012FX/Xr1zd+bUhNkZGRwauvvsquXbs4f/48+/fv54knnuDixYvGtVfWGD9+PGvXrmX+/PmcOnWKjz76yGQKrrh2FXwVTJmRlJTEgQMHjAHjiRMnOHDgAAkJCSb1btu2jT59+ljd1rKQYMlehLWG5vk/2OmlW7MghK1p2LAhe/fupX79+jz44INERETQr18/GjVqxPbt240LrZcsWcLgwYPN5vkZMmQIv/zyC9euXaNWrVrs2rWLO++8k9GjRxMVFcWDDz5IVFQUu3fvJjIyktzcXL755huGDBlitk1Dhgzhq6++Mjs9Bfq1LL6+vrRq1crYvh49eqDVaktcrzRz5kzOnTtHVFRUhU831K5dmzVr1rBnzx5at27NpEmTeOKJJ3j99deNZaZMmUL37t25++67GTBgAIMGDTJZK2WtFi1asGXLFk6ePMkdd9xB69atmTZtGmFhYWVq+4gRI8jKyqJDhw6MHTuWCRMm8PTTTwP60bClS5eyevVqmjZtyltvvWUMekuyYMEC/Pz86NKlC/fccw8xMTG0adOmTG0sSKvVMnbsWKKjo+nbty+NGjXik08+sVi+X79+ODo6smHDBpPj7u7uvPzyywwbNozbb78dT09PVq1aVaY2GUbhhgwZQqNGjbjnnnu4fv0627ZtMxmN7dGjR7H5njp16sQXX3zB+++/T8uWLVm/fr3Jz1BZ/PLLL7Ru3ZoBA/QPiAwdOpTWrVuzaNEiY5mdO3eSkpLC/fffX657lah02Q6EOdUmz9LxPxTlDW9FWdStcuovpeqae6gyVNe+2mqepbKYNm2a4unpqezcubNC662u/a0MttTXgrmoysJW+vrRRx8pffr0Mb435FkqrfL2t27dusa8XNYqa1tL48EHH1Rmz55tcqwy8izJmiV74pn/P86Mqs26KkRVmDFjBpGRkezatYsOHTqU6pF3Iaqr0aNHk5ycTFpaWqVueVKcI0eO4OPjw4gRI6rk/pbk5ubSvHlznn/++Uq/lwRL9uLCXjj5h/7r9CugKFCOLQaEsEUFc/wIYQ8cHR157bXXqrQNt912GwcPHqzSNpjj7Oxc7qk+a8l/vezF8V9h27v6r3UayCr946ZCCGEr4uLiKmxzYVsycuRIkpOTq7oZVrGltpZEgiV7YUhKaSBTcUIIIUSFkGDJXhiSUta/Ex7/A3zCq7Y9QgghhJ2QNUv2wpBn6bZBEFF0M04hhBBClI2MLNkLQ7Ak250IIYQQFUqCJXthmIa7cRZ2fw5nNlVte4QQQgg7IcGSvTCMLJ3fCX+8BIe/r9r2CCGEEHZCgiV7ce9H8NByqNdN/162PBHCZvXo0YOJEycWW2bp0qX4+vrekvZUFZVKxU8//QTAuXPnUKlUJW7EKqz36KOPMmfOnCptw6JFi7jnnnuqtA3WkGDJXkR0hui7IbCx/r0ES8KGjRw5EpVKVeR1+vRpY5kLFy7wxBNPEBYWhrOzMxEREUyYMIHr16+brXPFihWo1WrGjh1r9nxSUhITJ04kIiICZ2dnwsLCeOKJJ4iPjzdbfu7cuajVat55553yd7iQH374wWTT18jIyBqZU6ig8PBwLl++TLNmzaq6KXbhn3/+Yc2aNYwfP77S7pGdnc3IkSNp3rw5jo6ODBo0qEiZJ554gr/++ott27ZVWjsqggRL9sYzSP+n5FkSNq5v375cvnzZ5FWvXj0A/v33X9q1a8epU6dYsWIFp0+fZtGiRWzcuJHOnTuTlJRUpL7FixczefJkVqxYQXZ2tsm5pKQkOnXqxIYNG1i0aBGnT59m5cqVnD59mo4dO3Lu3Lki9S1ZsoTJkyezZMmSCu+7v79/lW1tUV2p1WpCQkJwdLTNh7hzc3OrugkmPvzwQx544AHjps6VQavV4ubmxvjx4+nVq5fZMs7OzgwbNowPPvig0tpRESRYsgeabNi3BA6uBo8C+8MpStW2S4hycHFxISQkxOSlVqsBGDt2LM7Ozqxfv57u3btTt25d+vXrx4YNG7h48WKR7SHOnj3Ljh07eOWVV2jUqBE//PCDyfnXXnuNS5cusWHDBvr160fdunXp1q0b69atw8nJiRdffNGk/JYtW8jKymLmzJmkpqayY8eOYvty//33M27cOOP7iRMnolKpOH78OKD/Rerh4WHcXb7gNFyPHj04f/48zz//vHGEraB169YRHR2Np6enMcC0RKvV8uSTT1KvXj3c3Nxo3Lgx77//vkmZZ599lsGDBzN//nxCQ0OpVasWY8eORaPRGMtERkYyZ84cnnjiCby8vKhbty6ff/65ST0XLlzgwQcfxNfXF39/fwYOHGgSdO7du5fevXsTEBCAj48P3bt356+//rLY9sLTcHFxcahUKjZu3Ei7du1wd3enS5cunDhxwuS6N998k6CgILy8vHjqqad45ZVXaNWqlcX7GOr9/fffadGiBa6urnTq1InDhw8by1y/fp2HH36Y2rVr4+7uTvPmzVmxYoVJPT169GDcuHFMnDiRgIAAYmJiAFiwYAHNmzfHw8OD8PBwnn32WdLTbyYVNkyv/vbbbzRu3Bh3d3fuv/9+MjMzWbZsGZGRkfj5+TF+/Hi0Wq3xuk8++YSGDRvi6upKcHAw999/v8U+arVavvvuuyLTX5GRkcyaNYuHH34YDw8Pateuzccff2yxnpJ4eHjw6aefMmrUKEJCQiyWu+eee/jll1/Iysoq870qmwRL9iDzOvz2PPz0DHjkjyxpcyE7uUqbJaqx3AzLL012yWU1mfl/ZllXbwVKSkpi3bp1PPvss7i5uZmcCwkJYfjw4axatQqlwH8WvvzySwYMGICPjw+PPPIIixcvNp7T6XSsXLmS4cOHF/kH3c3NjTFjxrBp0yaT0arFixfz8MMP4+TkxMMPP2xSnzndu3cnLi7O+H7Lli0EBAQYj+3duxeNRkOXLkVzpP3www/UqVOHmTNnGkfYDDIzM5k/fz5ff/01W7duJT4+vkhgV5BOp6NOnTqsXr2ao0ePMm3aNF599VX+7//+z6RcXFwcZ86cYfPmzSxbtoylS5eydOlSkzLvvvsu7dq14++//+bZZ59lzJgxxkBFo9EQExODl5cX27ZtY/v27cZgzjDCkpaWxmOPPcaff/7Jrl27aNiwIf379yctLa3Yz7Kw1157jXfffZd9+/bh6OjIE088YTy3fPlyZs+ezbx589i/fz9169bl008/tarel156iXfffZe9e/cSGBjIPffcYwwYs7Ozadu2Lb///juHDx/m6aef5tFHH2XPnj0mdSxbtgxnZ2e2b9/OokWLAHBwcOCDDz7gyJEjLFu2jE2bNjF58mST6zIzM/nggw9YuXIla9euJS4ujsGDB7NmzRrWrFnD119/zWeffcZ3330HwL59+xg/fjwzZ87kxIkTrF27lm7dulns28GDB0lJSaFdu3ZFzr3zzju0bNmSv//+m1deeYUJEyYQGxtrPN+vXz88PT0tvm677TarPt+C2rVrR15eHrt37y71tbeMIsotJSVFAZSUlJRiy+Xm5io//fSTkpubW7ENSDymKG94K8pbEfr3c8L176+cqNj7lFKl9bcaqq59zcrKUo4ePapkZWWZnnjD2/Lrm/tNy74ZYrnskv6mZefVM1+ulB577DFFrVYrHh4extf99+vbtWvXLgVQfvzxR7PXLliwQAGUxMRERVEURavVKuHh4cpPP/2kKIqiXL16VXF2dlb+/fdfRVEUJSEhQQGU9957z2x93333nQIoO3fuVBRF//fdzc1NOXDggKIoivL3338rnp6eSlpamsX+HDx4UFGpVMqVK1eUpKQkxdnZWZk1a5by0EMPKYqiKG+++abSpUsXY/nu3bsrEyZMML6PiIgo0r4vv/xSAZTTp08bj3388cdKcHCwxXaYM3bsWGXIkCGKoug/q4cffliJiIhQ8vLyjGUeeOABY1sN7XnkkUeM73U6nRIUFKR8+umniqIoytdff600btxY0el0xjI5OTmKm5ubsm7dOrPt0Gq1ipeXl/Lrr78ajxX8Pp89e1YBlL///ltRFEXZvHmzAigbNmwwlv/9998VwPjz3rFjR2Xs2LEm97n99tuVli1bKlqtVrlx44ai1WpNzhvqXblypfHY9evXFTc3N2XVqlUWPkVFGTBggPLCCy8Y33fv3l1p3bq1xfIGq1evVmrVqmV8b+77Onr0aMXd3d3kZywmJkYZPXq0oiiK8v333yve3t5KamqqxfsU7O+PP/6oqNVqk++Poui/r3379jU59tBDDyn9+vUzvv/vv/+UU6dOWXydO3fO7P0fe+wxZeDAgRbb5+fnpyxdutTi+dIo/L21+O+gYv3vb9uc/BWmDDmWnPPXODywBJw8wKdO1bVJiHK68847TUYBPDw8TM4rJUwzOzs7AxAbG0tGRgb9+/cHICAggN69e7NkyRKTRdQl1WewYsUKoqKiaNmyJQCtWrUiIiKCVatW8eSTT5q9plmzZvj7+7NlyxacnZ1p3bo1d999t3GKY8uWLfTo0cOq+xfk7u5OVFSU8X1oaChXrhT/cMfHH3/MkiVLiI+PJysri9zc3CLTUk2bNjVOeRrqPXTokEmZFi1aGL9WqVSEhIQY7/3PP/9w+vTpIuuusrOzOXPmDACJiYm8/vrrxMXFceXKFbRaLZmZmRYX1FtSsB2hoaEAXLlyhbp163LixAmeffZZk/IdOnRg06aS89B17tzZ+LW/vz+NGzfm2LFjgH4aa86cOfzf//0fFy9eJDc3l5ycHNzd3U3qaNu2bZF6N2zYwNy5czl+/Dipqank5eWRnZ1NZmam8frC39fg4GAiIyNN1hcFBwcbP+/evXsTERFB/fr16du3L3379mXw4MFF2mOQlZWFi4tLkSndwv02vC/4cEHt2rXN1llebm5uZGZmVkrdFcHmgqWPP/6Yd955h4SEBFq2bMmHH35Ihw4dzJb94osv+Oqrr4xzzW3btmXOnDkm5UeOHMmyZctMrouJiWHt2rWV14mKZsix5JL/D1MD8wvphDB69ZLlcyq16fuXTpu81el0pKal4e3lhYO60D8hE01/oZaHh4cHDRo0KHK8QYMGqFQqjh07xuDBg4ucP3bsGIGBgcbH6hcvXkxSUpLJlJ1Op+PgwYPMmDHDWNbwi7Cw48ePo1KpjG1ZvHgxR44cMVlorNPpWLJkicVgSaVS0a1bN+Li4nBxcaFHjx60aNGCnJwcDh8+zI4dO4qdPrPEycmpyH2KC/pWrlzJiy++yLvvvkvnzp3x8vLinXfeKTL9Ya5enU5ndZn09HTatm3L8uXLi7QhMFC/rvKxxx7j+vXrvP/++0RERODi4kLnzp1LvRC6YDsMv/wLt7WivfPOO7z//vssXLjQuP5o4sSJRdpeOMA/d+4cd999N2PGjGH27Nn4+/vz559/8uSTT5Kbm2sMbsx9tsV93l5eXvz111/ExcWxfv16pk2bxvTp09m7d6/Z9BIBAQFkZmaSm5tr/E+Ftfr161fsk2sREREcOXKkVHWCfnrd8LNRHdlUsLRq1SomTZrEokWL6NixIwsXLiQmJoYTJ04QFBRUpHxcXBwPP/wwXbp0wdXVlXnz5tGnTx+OHDliEh337duXL7/80vjexcXllvSnwhiDJdnqRFjJ2aPkMpbK6nTgpNUfd3AovmwlqFWrFr179+aTTz7h+eefNwmCEhISWL58uTE9wPXr1/n5559ZuXKlyVoKrVZL165dWb9+PX379uXBBx9k+fLlzJw502TdUlZWFp9++il33XUX/v7+HDp0iH379hEXF4e/v7+xXFJSEj169OD48eM0adLEbLu7d+/OF198gYuLC7Nnz8bBwYFu3brxzjvvkJOTw+23326xz87OziaLectq+/btdOnSxWS0xTDSU5HatGnDqlWrCAoKwtvb22JbPvnkE+OI34ULF7h27VqFtqNx48bs3buXESNGGI/t3bvXqmt37dpF3bp1Abhx4wYnT54kOjra2PaBAwfyyCOPAPrg7OTJkzRt2rTYOvfv349Op+Pdd9/FIf/vTuH1YmXl6OhIr1696NWrF2+88Qa+vr5s2rSJ++67r0hZw0ji0aNHi4wq7tq1q8h7Q78B/ve//xW7ELtwUGeNM2fOkJ2dTevWrUt97a1iUwu8FyxYwKhRo3j88cdp2rQpixYtwt3d3eKju8uXL+fZZ5+lVatWNGnShP/973/odDo2btxoUq7wUzd+fn63ojsVxzANZxhZuvwP7P5MtjwRduujjz4iJyeHmJgYtm7dyoULF1i7di29e/emUaNGTJs2DYCvv/6aWrVq8eCDD9KsWTPjq2XLlvTv39+4MHvOnDmEhITQu3dv/vjjDy5cuMDWrVuJiYlBo9Ewf/58QD+q1KFDB7p162ZSX7du3Wjfvn2xC7179OjB0aNHOXLkCF27djUeW758Oe3atSsyClFQZGQkW7du5eLFi+UKKBo2bMi+fftYt24dJ0+eZOrUqVYHD6UxfPhwAgICGDhwINu2bePs2bPExcUxfvx4/vvvP2Nbvv76a44dO8bu3bsZPnx4kQX75fXcc8+xePFili1bxqlTp3jzzTc5ePCg2emnwmbOnMnGjRs5fPgwI0eOJCAgwJgnqGHDhsTGxrJjxw6OHTvG6NGjSUxMLLHOBg0aoNFo+PDDD/n333/5+uuvjQu/y+O3337jgw8+4MCBA5w/f56vvvoKnU5H48aNzZYPDAykTZs2/Pnnn0XObd++nbfffpuTJ0/y8ccfs3r1aiZMmGA8X7t2bRo0aGDxFRERYVLf0aNHOXDgAElJSaSkpHDgwIEiiUW3bdtG/fr1TaYeqxubCZZyc3PZv3+/Sa4GBwcHevXqxc6dO62qIzMzE41GY/I/QtCPQAUFBdG4cWPGjBljMaldtVV4E92T6+GPybLlibBbDRs2ZO/evdSvX58HH3yQiIgI+vXrR6NGjYxPXoE+F9LgwYPN/nIcMmQIv/zyC9euXaNWrVrs2rWLO++8k9GjRxMVFcWDDz5IVFQUu3fvJjIyktzcXL755huGDBlitk1Dhgzhq6++MnnEvqDmzZvj6+tLq1atjO3r0aMHWq22xPVKM2fO5Ny5c0RFRZVrqmL06NHcd999PPTQQ3Ts2JHr168XWdNTEdzd3dm6dSt169blvvvuIzo6mieffJLs7GzjSNPixYu5ceMGbdq04dFHH2X8+PFmZwjKY/jw4UyZMoUXX3yRNm3acPbsWUaOHImrq2uJ17711ltMmDCBtm3bkpCQwK+//mqcsnr99ddp06YNMTEx9OjRg5CQELMJFwtr2bIlCxYsYN68eTRr1ozly5czd+7c8nYTX19ffvjhB+666y6io6NZtGgRK1asKPbJtKeeesrsNOkLL7zAvn37aN26NW+++SYLFiwwpj0oi/79+9O6dWt+/fVX4uLiaN26dZERpBUrVjBq1Kgy3+NWUCnWrmqsYpcuXaJ27drs2LHDZAHa5MmT2bJli1WPHD777LOsW7eOI0eOGP+yrFy5End3d+rVq8eZM2d49dVX8fT0ZOfOnSYLHAvKyckhJyfH+D41NZXw8HCuXbtmccgZ9I/TxsbG0rt37zINVVqUfB5VwiHwCEQJ74jq769xXPM8uga90T60ouTrK0ml9bcaqq59zc7O5sKFC0RGRlr1C8IaiqKQlpaGl5eXVf9Dv1WmT5/Oe++9x7p16+jUqVOF1Vtd+1sZakJf+/TpQ0hICMuWLTPb17i4OHr27Mn169ftajuZwt/brKwsoqOjWbFihfF3av369ZkwYYLJSFJlO3LkCL169eL48eP4+PhUSJ2F+5qdnc25c+cIDw8v8u9gamoqAQEBpKSkFPv726bWLJXHW2+9xcqVK4mLizP5sIYOHWr8unnz5rRo0YKoqCjjXxhz5s6dy4wZM4ocX79+vcWnDwoqmLOi4jgA1+HQGoJT4ukEpFw6zdY1ayrhXqVTOf2tnqpbXx0dHQkJCSE9Pb3CMwiXNh9OZZs0aRLBwcFs2bKFJk2aGNeEVJTq1t/KZC99zczM5Msvv+Suu+5CrVbz/fffs3HjRn788UdjHwv31fBEVlpaWoX/DFUHBfv7ySefEB8fbxyB0ul0ZGdnk5qaesvac+bMGT755BNUKlWF39fQ19zcXLKysti6dSt5eXkmZax9As9mgqWAgADUanWReeHExMRiM4MCzJ8/n7feeosNGzaYPGZqTv369QkICOD06dMWg6UpU6YwadIk43vDyFKfPn2qZmSpENXFEPj3PXwdc42LJ6tCdR1tqQzVta+GkSVPT0+7H1kCGDNmTIXXWZ37W9Hsra9OTk5s3ryZBQsWkJ2dTePGjVm9ejX33nuvxb4a/sPr5eVV7L/ntsZcfwv/fnBwcMDV1fWW9vvee++t8DrNjSy5ubnRrVs3syNL1rCZYMnZ2Zm2bduyceNG49ywYbF2wW0ECnv77beZPXs269atM5uttLD//vuP69evG/N1mOPi4mL2iTknJyerflFaW85qZ7fqN86t3Qb864NvGACqjKs4OTpCFf+jV+H9rcaqW1+1Wi0qlQoHB4cK+1+y4XFlQ732rib11976WnALmcIs9fWuu+6yOueWLbHme2tuD0RbVLivDg4OxvQLhf99tvbfa5v62zBp0iS++OILli1bxrFjxxgzZgwZGRk8/vjjAIwYMYIpU6YYy8+bN4+pU6eyZMkSIiMjSUhIICEhwbgPT3p6Oi+99BK7du3i3LlzbNy4kYEDB9KgQYNyLWi75XYtgu+fhH/j9O8N+8PJlidCCCFEudnMyBLAQw89xNWrV5k2bRoJCQm0atWKtWvXEhwcDEB8fLxJxPzpp5+Sm5tbZEPBN954g+nTp6NWqzl48CDLli0jOTmZsLAw+vTpw6xZs2wr11Ku4Wm4/NQBTq7g4gM5KZB+FdxsLBWCqHD2+D9lIYSwRkX8+2dTwRLAuHHjLE67FdyoEkoeUnRzc2PdunUV1LIqVDiDN+i3PHH2lC1PajjDE525ubkVnsNGCCFsgWERd3mWSNhcsCTMyDEkpSyQwVu2PBHon4Zzd3fn6tWrODk5Vcg6FJ1OR25uLtnZ2XaxrqUkNam/0lf7VZP6a+hrVlYW2dnZXLlyBV9fX4vpgKwhwZI9MG6kK9udCFMqlYrQ0FDOnj3L+fPnK6RORVHIysrCzc3NLp6YKklN6q/01X7VpP4W7quvr2+JT82XRIIle2BuGu7SAbiwGwIaQtRdVdIsUT04OzvTsGHDCsuzpNFo2Lp1K926datWT/5VlprUX+mr/apJ/TX0tXv37ri5uZVrRMlAgiVbp9MV3RsO4FQsbH4TWj8qwZIw5k+pCGq1mry8PFxdXe3+H12oWf2VvtqvmtRfQ19dXFwqJFACCZbsgAIPfqVft+Tqe/OwZ376gPQrVdIqIYQQwl5IsGTrHNTQdGDR4576dApkSLAkhBBClId9L4mvyTzyd+9Ov1q17RBCCCFsnARLti79Khz+Hs5uMz1umIbLuAKSkFAIIYQoMwmWbN2VI/DdE7DmJdPjhpElbS5kp9z6dgkhhBB2QoIlW5dj5kk4yN/yJH/naFnkLYQQQpSZLPC2dblmsncbPLBUH0T5ht/SJgkhhBD2RIIlW2cuIaVBg563ti1CCCGEHZJpOFtnCJaczQRLQgghhCg3GVmydcVNw106APG7ILCRZPEWQgghykhGlmxdcdNwp2Jh7ctw+Idb2yYhhBDCjsjIkq1rORRCWkDwbUXPGXMtSWJKIYQQoqwkWLJ1tdvqX+YYs3hL6gAhhBCirGQazp4Z9oeTYEkIIYQoMxlZsnVnNoNOC7XbgLu/6bnCW56oVLe+fUIIIYSNk5ElW/fHy7B8CCQeLnpOtjwRQgghyk2CJVtnzLNkJnWAbHkihBBClJtMw9k6Y54lb/PnH1ymT1gpW54IIYQQZSLBki1TlAJ5lsyMLIEkoxRCCCHKSabhbFluBqDovzaXlFIIIYQQ5SYjS7bMMAWncgAnd/NlLv2t3/IkoJFsrCuEEEKUgYws2bKc/GDJ2dNyWoBTsbD2FTjy461rlxBCCGFHZGTJlnnUgns/AkVruYxnfvoA2fJECCGEKBMJlmyZmx+0ebT4MrLliRBCCFEuMg1n72RkSQghhCgXGVmyZcnxcPUk+NSGoGjzZTzytzxJly1PhBBCiLKQkSVbdnKdfquTzbMtlzGMLGlzZMsTIYQQogxsLlj6+OOPiYyMxNXVlY4dO7Jnz55iy69evZomTZrg6upK8+bNWbNmjcl5RVGYNm0aoaGhuLm50atXL06dOlWZXag4htQBzsXkWHJyu5ndW6bihBBCiFKzqWBp1apVTJo0iTfeeIO//vqLli1bEhMTw5Ur5hcv79ixg4cffpgnn3ySv//+m0GDBjFo0CAOH7656ezbb7/NBx98wKJFi9i9ezceHh7ExMSQnZ19q7pVdsbs3SUkpHzwK3hqI/jUqfw2CSGEEHbGpoKlBQsWMGrUKB5//HGaNm3KokWLcHd3Z8mSJWbLv//++/Tt25eXXnqJ6OhoZs2aRZs2bfjoo48A/ajSwoULef311xk4cCAtWrTgq6++4tKlS/z000+3sGdlZMizZGmrE4OoO6FOO/0okxBCCCFKxWYWeOfm5rJ//36mTJliPObg4ECvXr3YuXOn2Wt27tzJpEmTTI7FxMQYA6GzZ8+SkJBAr169jOd9fHzo2LEjO3fuZOjQoWbrzcnJIScnx/g+NTUVAI1Gg0ajsdgHw7niypSGOjsVB0Dr6I6uguqsSBXd3+pM+mq/alJ/pa/2qyb1tzR9tfbzsJlg6dq1a2i1WoKDg02OBwcHc/z4cbPXJCQkmC2fkJBgPG84ZqmMOXPnzmXGjBlFjq9fvx53dwvbjhQQGxtbYhlrtD9/ijDg8KnznEteY7Gcb+a/+KefJM21Nle9m1fIvUujovprC6Sv9qsm9Vf6ar9qUn+t6WtmZqZVddlMsFSdTJkyxWTEKjU1lfDwcPr06YO3t7fF6zQaDbGxsfTu3RsnJ6dyt0P97RJIgdvadKJp8/4Wyzlsm4/6xLfoWj2Ctv/L5b6vtSq6v9WZ9NV+1aT+Sl/tV03qb2n6apgZKonNBEsBAQGo1WoSExNNjicmJhISEmL2mpCQkGLLG/5MTEwkNDTUpEyrVq0stsXFxQUXF5cix52cnKz6IbS2XIk6PQON+uAY3h6Kq89b30+HzOs4VMFfkgrrrw2QvtqvmtRf6av9qkn9taav1n4WNrPA29nZmbZt27Jx40bjMZ1Ox8aNG+ncubPZazp37mxSHvTDcoby9erVIyQkxKRMamoqu3fvtlhntdK4H3QeC4GNii9nzOItW54IIYQQpWUzI0sAkyZN4rHHHqNdu3Z06NCBhQsXkpGRweOPPw7AiBEjqF27NnPnzgVgwoQJdO/enXfffZcBAwawcuVK9u3bx+effw6ASqVi4sSJvPnmmzRs2JB69eoxdepUwsLCGDRoUFV1s+J55q/Jkv3hhBBCiFKzqWDpoYce4urVq0ybNo2EhARatWrF2rVrjQu04+PjcXC4OVjWpUsXvv32W15//XVeffVVGjZsyE8//USzZs2MZSZPnkxGRgZPP/00ycnJdO3albVr1+Lq6nrL+1dq/8aBkzuEtgTHotOCRrLliRBCCFFmNhUsAYwbN45x48aZPRcXF1fk2AMPPMADDzxgsT6VSsXMmTOZOXNmRTXx1lAU+Po+ULQw6Th4h1ouW3DLk5xUcPW5NW0UQggh7IDNrFkShWiy9IESlJzBu+CWJzIVJ4QQQpSKzY0siXyGfeFQgbNHyeUf+lq/h5xseSKEEEKUigRLtqrgvnDWrEGq36NSmyOEEELYK5mGs1WGYMm5hH3hhBBCCFEuMrJkq3Kt3ETX4OJ+OL8TgqKhQc/Ka5cQQghhZ2RkyVYVnIazxumNsP41OPpTpTVJCCGEsEcysmSrAhpBn9ng7m9deWOupauV1yYhhBDCDkmwZKtqRUEX8/mmzJItT4QQQogykWm4msIjP1iSkSUhhBCiVGRkyVYl/QsZ1/V5k4rL3m3gaZiGS5QtT4QQQohSkJElW7X7c1jcC/Z8Zl15j0JbngghhBDCKhIs2arcUuZZcnbXZ/AGmYoTQgghSkGm4WyVMXWAt/XXDF2uz8skW54IIYQQVpNgyVblFE1KefZaBhk5eTSr7WP+mvrdb0HDhBBCCPsiwZKtKpSUUlEU7pwfB8DfU3vj5+FcRQ0TQggh7IusWbJVhu1O8tcsJWXkGk8lpmWbv+biftjxoT6btxBCCCGsIsGSrTJOw+lHltQON1MBZGt05q85tQHWvw5Hf67s1gkhhBB2Q6bhbNXt4yHjKviEA+Dr7kzjYC9OJKaRlq0xf40h11KGPA0nhBBCWEuCJVvVYVSRQ16u+m9nenae+Ws8g/V/pidWVquEEEIIuyPTcHbi9JV0ElL1a5XSLAVLsuWJEEIIUWoSLNmivBz4bx9cPWE8NH/dCf67kYWvuxPRoRZyLxmn4a7otzwRQgghRIkkWLJFKf/B/3rCF3cZD11KyQLgnftb0ryOhTxLhpGlvGzZ8kQIIYSwkgRLtqhQ2gCAS8n6YCnM19XydbLliRBCCFFqssDbFhXK3p2t0XItXZ9nKStXS/z1TOrWcjd/7dDl+nQDsuWJEEIIYRUZWbJFhbJ3G0aVAO5ftJN5a49bvrZ+d6jdBpyKGYESQgghhJEES7ao0DTcpWTTjN2plvIsCSGEEKLUZBrOFhkWZ7von3orOLIEkJ5jIXUAwH/74fx2CG4KDXpVVguFEEIIuyEjS7ao0JqlZrV9eKF3Ix5oq1+HZDHPEsDpDRA7FY7+UtmtFEIIIeyCjCzZovAO0G2yfnQIaBrmTdMwbw79l8Lq/f9Z3u4EZMsTIYQQopQkWLJFdTvpX4WUuN0JFMjifaUyWiaEEELYHZuZhktKSmL48OF4e3vj6+vLk08+SXp6erHln3vuORo3boybmxt169Zl/PjxpKSkmJRTqVRFXitXrqzs7lSo3f9e5/SVNNyc1QBk5GrR6ixk6PaUYEkIIYQoDZsZWRo+fDiXL18mNjYWjUbD448/ztNPP823335rtvylS5e4dOkS8+fPp2nTppw/f55nnnmGS5cu8d1335mU/fLLL+nbt6/xva+vb2V2pfyS/gVtHniHonPy5NEle8jN07Hphe48fnskXq5OaHUKagdV0WsNwZJhyxOVmTJCCCGEMLKJYOnYsWOsXbuWvXv30q5dOwA+/PBD+vfvz/z58wkLCytyTbNmzfj++++N76Oiopg9ezaPPPIIeXl5ODre7Lqvry8hISGV35GKsmYynI6FgZ9wrcEQcvN0qFQQ7u/OG/fcVvy1JluepIGrhX3khBBCCAHYSLC0c+dOfH19jYESQK9evXBwcGD37t0MHjzYqnpSUlLw9vY2CZQAxo4dy1NPPUX9+vV55plnePzxx1EVM+KSk5NDTk6O8X1qqv5Rfo1Gg0ZjeXG14VxxZayhzk7FAchzdCf+mn4qMsjLBXRaNDpt8RernHB09kCVm4Em5RKo3crVluJUVH9tgfTVftWk/kpf7VdN6m9p+mrt52ETwVJCQgJBQUEmxxwdHfH39ychIcGqOq5du8asWbN4+umnTY7PnDmTu+66C3d3d9avX8+zzz5Leno648ePt1jX3LlzmTFjRpHj69evx93dwjYjBcTGxlrVZkt6XLuED7DnwFFiNWpAjZsumzVr1pCmgQwN+LqAq9r89QF1n0OjdiNtxyF0DifK1RZrlLe/tkT6ar9qUn+lr/arJvXXmr5mZmZaVVeVBkuvvPIK8+bNK7bMsWPHyn2f1NRUBgwYQNOmTZk+fbrJualTpxq/bt26NRkZGbzzzjvFBktTpkxh0qRJJvWHh4fTp08fvL0tT2tpNBpiY2Pp3bs3Tk5OZe6P47+vQzZ0uOMuDp0LgJMnua1eKP37t2Dwp7s4fCmVLx5tTY9GgRZq6F/me5dGRfXXFkhf7VdN6q/01X7VpP6Wpq+GmaGSVGmw9MILLzBy5Mhiy9SvX5+QkBCuXDF9eisvL4+kpKQS1xqlpaXRt29fvLy8+PHHH0v84Dp27MisWbPIycnBxcXFbBkXFxez55ycnKz6IbS2nEX52504uvuRkKbfQLeOvztOTk54uerrzcqjQv9CpGVreGTxHnpHBzHuroalurbc/bUh0lf7VZP6K321XzWpv9b01drPokqDpcDAQAIDLY1+3NS5c2eSk5PZv38/bdu2BWDTpk3odDo6duxo8brU1FRiYmJwcXHhl19+wdW15M1jDxw4gJ+fn8VAqVrIvZnB+1Kyfhqytq9+7ZEh11KxiSn/25e/5cltVm95su/8Df65kMw/F5JLHSwJIYQQtswm1ixFR0fTt29fRo0axaJFi9BoNIwbN46hQ4can4S7ePEiPXv25KuvvqJDhw6kpqbSp08fMjMz+eabb0hNTTUOtwUGBqJWq/n1119JTEykU6dOuLq6Ehsby5w5c3jxxRersrvFy8sBrX40CRcvhrZ3plmYD+0i/AHwNAZLJWx5EjcX2o60OlhqGKTfWsVJrUJRlGIXwAshhBD2xCaCJYDly5czbtw4evbsiYODA0OGDOGDDz4wntdoNJw4ccK4WOuvv/5i9+7dADRo0MCkrrNnzxIZGYmTkxMff/wxzz//PIqi0KBBAxYsWMCoUaNuXcdKS1Gg20v6/eGcPbmziQ93Nrm5+N07fxqu+Cze+aN56dZveRLopR9p02gVbmRq8PdwLn3bhRBCCBtkM8GSv7+/xQSUAJGRkSjKzazVPXr0MHlvTt++fU2SUdoEJ1e463WLpz1drJiGM2bxTrT6tqlZN4OvK2nZEiwJIYSoMWxmuxNRVEqmhrgTVzhz9ea2L8Y1SzlW7A+XYf2WJ0u2nzV+fSU1p5iSQgghhH2RYMnW5KTDtVOQfpWDF5MZ+eVexnyz33i6RR1fRnaJpLvFtAEUGFm6qp/Ws0Jq1s2RqitpEiwJIYSoOWxmGk7kO78Dvn0AQltysfU3AIT53szC3TmqFp2jahVfhyFYysuyesuTlALBUmJqdunbLYQQQtgoGVmyNblp+j+dvbiUnAXcTBtgNWcPcPLQf51h3SLv1PwF43c0DKBvMxvaR08IIYQoJxlZsjU5+cGSixcXk/UjPAVHlvK0OpIycsnW6Khbq5itV4atBBdv8K5t1W0NI0sjOkcSFehZtrYLIYQQNkiCJVuTUyAh5fWiI0unr6bTd+E2ank4s39qb8v11OtWqtum5QdL3q7yIyOEEKJmkWk4W2MYWXL25FKKPlgqOLJk2O6k2KSUZZCan4rgr/hkfvnnUoXWLYQQQlRnMkxga/K3OlGcvbicPw1X2+9msGTIs5Sr1ZGTp8XFUW2+HsOWJ0G3QcOSs3gP61CXvy8kM2/tcVwcHbinRahk8RZCCFEjyMiSrckfWdI5e/LWkOa80LsRwV4397EzBEtgxZYnsdPg+K9W3XZSn8Z8MaKdvgl5OuOCbyGEEMLeyciSranfA5zcUIe3474GdYqcVjuo8HRxJD0nj/TsPAI8LWwIXIYtT1yd1Hi5OpKWncfVtGx83GrGztVCCCFqNgmWbE2z+/SvYhiCpWJHljyD9X9akcU7W6PlaloO3m5OBHu7kpadTmJqDg2CvErTciGEEMImSbBko45dTiUxNZtGwV4mC7xBv+VJQiqk5VTM/nCHL6Zw/6KdRNRyp7avG6evpHMlTRJTCiGEqBlkzZKtSY6HtARW7znLyC/38vWu80WK3NMyjJFdIgnysjAFBzdHltISIOtGsbc0PAnn7epkrFP2hxNCCFFTyMiSrVl2D9w4h1PYB0BAkVElgPE9G5Zcj29d/ZNwV47A7s+gxysWi6Zm6afzfNycCPJ2BWR/OCGEEDWHBEu2Jj8p5YV0/aBgbV/XstWjUkG3F+G7x+HyP8UWNY4suTlyd4tQokO9aBrqU7b7CiGEEDZGgiVbk59n6WyaPlgyN7KUrdGSmq3BWe2Ar7uz5bqaDoQn1kHdTsXeMiXz5jRcizq+tKjjW7a2CyGEEDZI1izZEq0G8vQLqy9m6eNcc5vozl93gg6zN/Jp3Jni63NQlxgoQcGRJUkVIIQQouaRYMmWGLY6ATJww8vV0bi9SUGGY6VKHJmZBOd3mD1VcM1STp6WTccT+b+9F0rRcCGEEMJ2yTScLckPlrRqF7SozY4qAXjmb3abnmNlsHTpACwdAI6uMPEQOLubnO4cVQu1WkXz2j5otApPLN0HQP8WoSYZw4UQQgh7JL/pbEn+eiVcvFgwoCWOavMDg175wVJadjF5lgoKvg3ca0Hyedj/JXQea3J6UOvaDGpd2/jew1lNRq6WK6nZeAZ6lr4fQgghhA2RaThb4uINHZ5G3WoY97Wpw70tw8wW88of7Um3dhpO7QR3vKD/evv7oMkqtrikDxBCCFGTSLBkS3zDof870GdWscUMa5aK3e6ksJYPg0+4PqP3X1+bnLqUnEVKpgadTgEg0JCYUoIlIYQQNYAESzZow9FEtpy8SkqW+Wk2z9JOwwE4OkPX5/Vf//ke5N0MhPq9v42WM9fz7zX9NGCwYWQpVbY8EUIIYf8kWLIl2amQlsicX/7isSV7OJWYZrZYsLcLQ9rU4d5Wtc2et6j1I+AVBmmX4MByAHQ6xRh0eeePWBm2PLkqI0tCCCFqAAmWbMnf38C7jXg+433AfEJKgFAfN959sCWv9GtSuvodXaDrRHBw0u8ZB6Tn5pE/+2bMsxQk03BCCCFqEHkazpbkpw5IU9xQO6iK3yi3rNqMgMb99eujgNT8qT5nRwdcndQA3NUkiGBvVxoEyZNwQggh7J8ES7YkVx8speNGiLerxdQBcHPLEz93Z5yKKVeEk5sxUIKbCSm9CyS/bBjsRcNgr1I2XgghhLBNMg1nS/I30U1X3CwmpDToPHcjHWZv5Ny1jLLfL+EQnNsGgI+bxNVCCCFqJgmWbEn+NFwGroT5uhZb1PhEnLVZvAs7+jMs6krEjldxQGeyL5xOp7DxWCIr9sSTk6ctW/1CCCGEjZDhAluSn8E7DTeLi7sNvFycgKzS5VoqKOoucPPDI/0ccxqd4nq9e42nVCp4dvlf5OTpuD0qgLq13IupSAghhLBtNjOylJSUxPDhw/H29sbX15cnn3yS9PT0Yq/p0aMHKpXK5PXMM8+YlImPj2fAgAG4u7sTFBTESy+9RF5eGQOMypY/sjSkUxP6NQsttmiZci0V5OJl3PZkaOZKxnavbzylUqkI8jY8ESe5loQQQtg3mxlZGj58OJcvXyY2NhaNRsPjjz/O008/zbffflvsdaNGjWLmzJnG9+7uN0dBtFotAwYMICQkhB07dnD58mVGjBiBk5MTc+bMqbS+lFnDPuBbl45t20GYT7FFvV1LueWJOR2ehh0fwrUTcOxnuG2w8VSQlysXkrIkfYAQQgi7ZxMjS8eOHWPt2rX873//o2PHjnTt2pUPP/yQlStXcunSpWKvdXd3JyQkxPjy9vY2nlu/fj1Hjx7lm2++oVWrVvTr149Zs2bx8ccfk5ubW9ndKr2uE2HwIghrVWJRTxfDyFI5giVXH7LbPA2AsvUd0OmMp4INI0uSxVsIIYSds4mRpZ07d+Lr60u7du2Mx3r16oWDgwO7d+9m8ODBFq9dvnw533zzDSEhIdxzzz1MnTrVOLq0c+dOmjdvTnBwsLF8TEwMY8aM4ciRI7Ru3dpsnTk5OeTk3BxRSU1NBUCj0aDRWJ72MpwrrkxxsnK1/PzPZcJ8XbmjQS1UKpXFsh7O+pxIKZk5Zb4fwMyrdzBF+QivxCPkHf0VpXF/AGp5OAOQkJJlsf7y9teWSF/tV03qr/TVftWk/pamr9Z+HjYRLCUkJBAUFGRyzNHREX9/fxISEixeN2zYMCIiIggLC+PgwYO8/PLLnDhxgh9++MFYb8FACTC+L67euXPnMmPGjCLH169fbzLNZ0lsbGyJZcy5kZrK3COeOKgdeauDrtiyqiQV7QNVZFw6xZo1J8t0P4CD/zmwTNuHx5zjOLF3JxfP5LflkgpQ89exM6zRnCq2jrL21xZJX+1XTeqv9NV+1aT+WtPXzMxMq+qq0mDplVdeYd68ecWWOXbsWJnrf/rpp41fN2/enNDQUHr27MmZM2eIiooqc71Tpkxh0qRJxvepqamEh4fTp08fk2m+wjQaDbGxsfTu3RsnJyeL5czS5eE0N4SRrvCA1zf079+/2OLFn7XeN5f38umNe4kcNJWYlpG0zD+e/fdFfos/grNPIP37tzV7bbn6a2Okr/arJvVX+mq/alJ/S9NXw8xQSao0WHrhhRcYOXJksWXq169PSEgIV65cMTmel5dHUlISISEhVt+vY8eOAJw+fZqoqChCQkLYs2ePSZnExESAYut1cXHBxaXoViNOTk5W/RBaW85E1s0n//z8a92yH/a07DwycMPHx9fknl0aBPH+UCcia3mU2JYy9ddGSV/tV03qr/TVftWk/lrTV2s/izIt8J45c6bZoausrCyTJ89KEhgYSJMmTYp9OTs707lzZ5KTk9m/f7/x2k2bNqHT6YwBkDUOHDgAQGio/rH7zp07c+jQIZNALDY2Fm9vb5o2bWp1vbdEftqAHMWJYD/Lo1cGiqKQrdGSklW++WnD3nA+bk6QmwEX9oBWQ7i/OwNb1aZluG+56hdCCCGquzIFSzNmzDCb4ygzM9PsWp7yio6Opm/fvowaNYo9e/awfft2xo0bx9ChQwkLCwPg4sWLNGnSxDhSdObMGWbNmsX+/fs5d+4cv/zyCyNGjKBbt260aNECgD59+tC0aVMeffRR/vnnH9atW8frr7/O2LFjzY4cVSnDVie4Utuv+ISUAJuOX6HJ1LWMWLy7XLdNzX+aztvFERY0hcW94VrZ10AJIYQQtqZMwZKiKGafxPrnn3/w9/cvd6PMWb58OU2aNKFnz57079+frl278vnnnxvPazQaTpw4YRzxcnZ2ZsOGDfTp04cmTZrwwgsvMGTIEH799VfjNWq1mt9++w21Wk3nzp155JFHGDFiRKlGx26Z/OzdGYpridm7oUDqgLJudwLkaXWk51/v7e4MwbfpT1z+B4DNJ67w7e54UjLt/+kKIYQQNVep1iz5+fkZM2E3atTIJGDSarWkp6cXyZBdUfz9/YtNQBkZGYmiKMb34eHhbNmypcR6IyIiWLNmTYW0sVLl6BehpeNO7RL2hYOCGbzLESzpFIZ1rEtqlgYvV0cIbQnnt+uDpVbDeO2HQ1xKySY61IvWdf3KfB8hhBCiOitVsLRw4UIUReGJJ55gxowZ+PjczCLt7OxMZGQknTt3rvBGCozTcEEBtXAK8iqxuLerftFaeTJ4uzqpmTO4+c0DIfrpSy4fBCDQ25VLKdmSxVsIIYRdK1Ww9NhjjwFQr149br/9dhwdbSJNk33wDoMWDxFQqwG4lbx63zANl6XRotHqcFJXQLL20PzEAQkHQacj2EuyeAshhLB/ZfoN6uXlZZL/6Oeff2bQoEG8+uqr1XObEHsQ3gHu+xy6T7aquGEaDiCjjOuWsjVaUjI16HT505sBjcDRVb9+KunfApvpysiSEEII+1WmYGn06NGcPKl/Iurff//loYcewt3dndWrVzN5snW/zEXpHLucyre74zlwIdmq8k5qB9yc9FuelHXd0sZjV2g5cz1DP9+lP6B2LLDI+wBBXvq1U1dSJVgSQghhv8oULJ08eZJWrVoBsHr1arp37863337L0qVL+f777yuyfSLfn0fjmfHjfr7aftbqa/o3D+W+1rXLPAWXmq1/ys3brcB0a/unIGYuhLW+uZlumkzDCSGEsF9lWnSkKAq6/B3oN2zYwN133w3on0C7du1axbVOGLU8+g4nXH9ie/rTgPkNfgt798GWJRcqhiEhpWGxOACthhm/DLqqT+aZKCNLQggh7FiZgqV27drx5ptv0qtXL7Zs2cKnn34KwNmzZ4tsTCsqhjZbn8HbzbPk7N0V5ebIkvkF5c1q+/D+0FbUsSJJphBCCGGryhQsLVy4kOHDh/PTTz/x2muv0aBBAwC+++47unTpUqENFPnyUwd4ePtafYmiKOTk6VCpwMVRXepbGrZKKRIsXT0Blw4Q2KAnA1vVLnW9QgghhC0pU7DUokULDh06VOT4O++8g1pd+l/KomTqPH2w5ONjfYb0cd/+ze+HLjNr4G082jmy1PdMzcrP3u1a6Mfkuych8RA8tByi7y51vUIIIYQtKVeipP379xtTCDRt2pQ2bdpUSKOEqbRsDa66THAAX1/rgyU3Z33gmlrGp+EsTsOFttQHS5f/4U/HTpxPyqBnk2BCfErOLC6EEELYmjIFS1euXOGhhx5iy5Yt+Pr6ApCcnMydd97JypUrCQwMrMg21niXkrPxQP/EmaunTwmlb/LKHxFKL2OepU71a+Hh4khUoIfpidCWcOAbuPwP844c59DFFEIec5VgSQghhF0q0zPlzz33HOnp6Rw5coSkpCSSkpI4fPgwqampjB8/vqLbWOOF+7sR7pEf8LiUvNWJgVf+U2xp2WXb6PaZ7lF8PKwNbSMKjWaF5m97knCQoPws3vJEnBBCCHtVppGltWvXsmHDBqKjo43HmjZtyscff0yfPn0qrHFCz93ZEaL7QcY1cA+w+jqv/C1PyrM/nFnBzQAVpF2mfp0MNiK5loQQQtivMgVLOp0OJ6eij5M7OTkZ8y+JCnbvh6W+xDANV9YM3imZGjxdHVE7qExPuHhCQEO4dpKmqrNAkGx5IoQQwm6VaRrurrvuYsKECVy6dMl47OLFizz//PP07Nmzwhon9H4/eJkVe+K5kJRZqus8yxEsZWu0tJy5nqhX1xgXepsI0U/F1dOcBmQzXSGEEParTMHSRx99RGpqKpGRkURFRREVFUW9evVITU3lww9LPwIiirds+xmm/fA3//yXXKrrwv3c6RUdTId61j9BZ2AIkFQq8HQ2MwDZ4Wl4eBXJ0cMB2UxXCCGE/SrTNFx4eDh//fUXGzZs4Pjx4wBER0fTq1evCm2c0HO6cYZTruPJ/SMIWpyy+rqW4b7877F2ZbqnIceSl4sjDoWn4QDqdgTA70IycFY20xVCCGG3ShUsbdq0iXHjxrFr1y68vb3p3bs3vXv3BiAlJYXbbruNRYsWcccdd1RKY2uiPK2O7IxkcAK1k8stu69hZMnH3fxWJwb1Az14f2grQn1kyxMhhBD2qVTTcAsXLmTUqFF4exfdn8zHx4fRo0ezYMGCCmucgMS0HNyULAAcXK1PG1BQTp4WRVFKdY3ZTXQL+zcOr53vMDDkRpmm+oQQQghbUKpg6Z9//qFv374Wz/fp04f9+/eXu1HipkvJWXigD5ZUpcixBJCZm0ej1/6g8etrydaU7inFFGuCpb3/gy3z4N+4UtUthBBC2JJSBUuJiYlmUwYYODo6cvXq1XI3Stx0KTkLL5U+WCpNQkoANyc1efmpHNJySpeY0rBFirdbMTO1oS0BuHpqD9/sOs/ZaxmluocQQghhC0oVLNWuXZvDhw9bPH/w4EFCQ0PL3Shx0383soxbneDsWaprVSoVni5lSx8Q7ufGgBahtI8sZnottBUAuf/9zes/HWbv2aRS3UMIIYSwBaVa4N2/f3+mTp1K3759cXU13QcsKyuLN954g7vvll3oK9JD7cPJTAmAA+iTQZaSl6sTqdl5pQ6WejQOokfjoOIL5edaCtX8hxvZksVbCCGEXSpVsPT666/zww8/0KhRI8aNG0fjxo0BOH78OB9//DFarZbXXnutUhpaUwV4ukBUU8jsZxzJKQ3jZroVveUJgFcweIbgkJ5AtCqeK2mNK/4eQgghRBUrVbAUHBzMjh07GDNmDFOmTDE+YaVSqYiJieHjjz8mODi4UhpaozW/X/8qg5vTcKVbs5SVq8XZ0aHoVieFhbaEUwnc5nCORMniLYQQwg6VOillREQEa9as4caNG5w+fRpFUWjYsCF+fn6V0b4ab+GGkwR5uTK4dW3cnNWlvt64P1xO6UaWRn21jz9PX+P9oa0Y2Kq25YKhLeDUOqJV8RyWLN5CCCHsUJkyeAP4+fnRvn37imyLKCQlS8PCDadQoWNQ67Ay1dG6rh9qBweCvEqX0NKQlNIwMmVR25EcrhXD6ysSCJUs3kIIIexQmYMlUfkuJetTBqxynYv7vCdhyBfQdGCp6hjfs2GZ7m1MSulWfAZvfOrgW9cfHVe4mpaDoiioVCVM3QkhhBA2RIKlaswQLPmqc0GbA+pbt92JISmlT0nBEhDk5coHD7cmyMsFRdFvviuEEELYi1LlWRK3liFY8nYoW1LKgrQ667c7URTlZlLK4jJ453M+8Qv3np5Gp+zt5jfdFUIIIWyYzQRLSUlJDB8+HG9vb3x9fXnyySdJT0+3WP7cuXOoVCqzr9WrVxvLmTu/cuXKW9GlEl1M1j9dZkxKWYY8Syv3xNPo9T8Yv+Jvq6/JzNUag6tiM3gbG7ofDq2Gs1tK3T4hhBCiurOZYGn48OEcOXKE2NhYfvvtN7Zu3crTTz9tsXx4eDiXL182ec2YMQNPT0/69etnUvbLL780KTdo0KBK7o11DCNLLrpM/YFSZvAGcFI7kJunK9XTcIbF3U5qFW5OVjyBZ9j25OQeDl9MKXUbhRBCiOrMJtYsHTt2jLVr17J3717atWsHwIcffkj//v2ZP38+YWFFnxRTq9WEhISYHPvxxx958MEH8fQ0DTp8fX2LlK0OLiZnoUKHszY/WHLxLnUdnq6lz7PkoFIxoEWo9Yu184Mlz+TjfHcygWa1fUrdTiGEEKK6somRpZ07d+Lr62sMlAB69eqFg4MDu3fvtqqO/fv3c+DAAZ588ski58aOHUtAQAAdOnRgyZIlxmSbVe39oa1Y9VjzmwfKtN1J6TN4B3u78vGwNnwyvK11F/hHkePgjpsqF92VU6VuoxBCCFGd2cTIUkJCAkFBpvuUOTo64u/vT0JCglV1LF68mOjoaLp06WJyfObMmdx11124u7uzfv16nn32WdLT0xk/frzFunJycsjJuZlTKDU1FQCNRoNGY3kEx3CuuDIFBXs6EVzbA12DPqDJRKuowcprDdzU+pGh1Ozi21ZeN7waEZJyAPfrh9BoYoDS99eWSV/tV03qr/TVftWk/pamr9Z+HiqlCodRXnnlFebNm1dsmWPHjvHDDz+wbNkyTpw4YXIuKCiIGTNmMGbMmGLryMrKIjQ0lKlTp/LCCy8UW3batGl8+eWXXLhwwWKZ6dOnM2PGjCLHv/32W9zd3Yut/1a7mgVvHnDERa3wdgetVddodfrH/0vzYFvwqW/olL6e1Q79cG75cBlbK4QQQtw6mZmZDBs2jJSUFLy9LS91qdKRpRdeeIGRI0cWW6Z+/fqEhIRw5coVk+N5eXkkJSVZtdbou+++IzMzkxEjRpRYtmPHjsyaNYucnBxcXMznNZoyZQqTJk0yvk9NTSU8PJw+ffoU+2FrNBpiY2Pp3bs3Tk4lP5JfEa5n5PLmgThytCpi+vYrea83YNnO88z+4wSDWoXx9n3NrLrP+U2XyduxAXdVDn369weqpr9VRfpqv2pSf6Wv9qsm9bc0fTXMDJWkSoOlwMBAAgMDSyzXuXNnkpOT2b9/P23b6tfRbNq0CZ1OR8eOHUu8fvHixdx7771W3evAgQP4+flZDJQAXFxczJ53cnKy6ofQ2nIA5c3y6OfpQId6/ni7OoKDGicrnm7LyFVQFHBzdrS6nc4th3Db5mBUOleOOTqaLAwvVX9tnPTVftWk/kpf7VdN6q81fbX2s7CJNUvR0dH07duXUaNGsWjRIjQaDePGjWPo0KHGJ+EuXrxIz549+eqrr+jQoYPx2tOnT7N161bWrFlTpN5ff/2VxMREOnXqhKurK7GxscyZM4cXX3zxlvWtRMd/g++fgnrdYPjqkssX4uKo5v9Gdy7VNYbUAdYkpDQI9PcnB2fQ6NMUlOZaIYQQojqziWAJYPny5YwbN46ePXvi4ODAkCFD+OCDD4znNRoNJ06cIDMz0+S6JUuWUKdOHfr06VOkTicnJz7++GOef/55FEWhQYMGLFiwgFGjRlV6f6yWkw552aCzbr1RRbi5L5z1Px5uzmo+Gd6GWh7OuDpakZtJCCGEsBE2Eyz5+/vz7bffWjwfGRlp9pH/OXPmMGfOHLPX9O3bl759+1ZYGytFbn6W8jKkDSjM2rxJhn3hSjs61F/5EzZ+Cg37QI9XytRGIYQQorqxiTxLNVpO/uKzcuwL98j/dtPo9T+IO3HVqvKGaThrNtE1kZOq3/rkwp7SNlEIIYSotiRYqu5y8keWnMseLOXpdOTm6YxBUElSs/I30S1lsHRKHQWA5uIB/cJ0IYQQwg5IsFTdVcA0nFf+dFq6lfvDtY/0446GAYR4u5bqPj9c9CZPccAp+zqkXip1O4UQQojqyGbWLNVYOWn6P8sxDedl3B/OumBpxkDrcisVVsvXl9NKbZqoLkDCQajfq0z1CCGEENWJjCxVd7WioG4X8I0ocxVeLqXfH64sAr1cOKJE6t9c/qdS7yWEEELcKhIsVXfdXoIn/oDbBpW5CsM0XJoVa5YURUGrK9t6oyAvVw7rIvVvJFgSQghhJyRYqgE8DdNwVqxZ+u9GFlGvrqH97A2lvk+wtwuHdfW4qASCZ3CprxdCCCGqI1mzVANE+LvTIdKf+gEeJZY15FgqywYrQd6u7FWacHvO+xyNicEJeSJOCCGE7ZNgqbr7oI1+kfeInyG4aZmq6Nc8lH7NQ60qa8jeXeocS4CniyPuzmoyc7VcSc2hto9zqesQQgghqhsJlqq79CuQmwbqWxN4GPeFK0OwBPDRsNZ4ujgR4u1yM+2BEEIIYcNkzVJ1pigF8iyVPXVAaRgTUrqWLY6+q0kwHdI34fpeA9S/ja/IpgkhhBBVQoKl6iw3AwzrfsqRlPLfq+m0e3MDt7+1qcSyKeWYhjNy94esG6gSDpa9DiGEEKKakGCpOjMkpFQ5gJN7matxcVJzLT2Hq+k5JZYt7zTcscuprPrPDwDVjbM4arPKVI8QQghRXUiwVJ3lFtgXTlWW59P0PPOTUubm6cjJ0xZbNtzPnTsaBtA4pGzTfltOXuXlPy6R5KhPHeCTdb5M9QghhBDVhSzwrs6MW52UfQoObgZLoM/i7eKptlj2wfbhPNg+vMz3CvJyAeCMYxT+eYkEph3R98PJX18g6Syc2aQ/lpOa/2caZKeCgwN0fR5qty3z/YUQQoiKJsFSdaZ2grqdwb1W+apxUOHhrCYjV0tadh61PF0qqIFFBXnpN989qkTSnh00TviZvNMDoNVD+gKJh+H3SZYr8IuUYEkIIUS1IsFSdRbSHJ5YWyFVebk6GYOl4iiKgqocU37B3vpA7Oecdoxw+wNtdgZoc28W8AmHJnfrn+5z8c7/0wuc3ECTBbdPKPO9hRBCiMogwVIN4enqCKmQllP8/nB9F27jUnIWXz7ennaR/qW+j2Fk6a/sEDJeOsbGDevp36L/zQJhrWDo8pIr0mogL6fcU5BCCCFEeUmwVEM0r+2Dn7sTLo6W1ysBJGflkpaTh6tT8eUs8XZzxNnRgdw8HVczSt6418BkRCsnHVY/BooOhv2ffjpSCCGEqCLyNFx1tvMTmN8IYt8od1XvPdSK1c90oW2EX7HlbialLFuAolKpjIu8r6aVnKoAYPvpazz02S4up+SnGbhxFs7v0C8E/3WCPjmnEEIIUUUkWKrOMq9DeqJ+Lc8tkJunI0ujTy3g7Vb2Qce3h7Rg9TOdaRhc8hRaYmo2E1b+zZ5zSXyx9az+YEhzeGAZqNRwYDnEzS1zW4QQQojykmCpOjOmDrhFW51k35w28yrjyBJAlwYBtI/0N0lZYE6eVsdzK/7mWnoufu5OxCdl8OTSvfqTjfrA3Qv0X2+ZB/uXlbk9QgghRHlIsFSdGfeFK/8i50/iTtN+9gYWrD9hsUxq/lYnXi6OqB3K/kSctRbEnmTP2SQ8XRz5fEQ7Nhy7wqYTV9BodfoCbUdCt8n6r397Hk6ur/Q2CSGEEIVJsFSd5aTq/3Quf7CkyVO4mpbDtYxci2VS89MKlHWrE4PTV9JZtuMca48kWiyz+cQVPok7A8BbQ5rTLsIPZ0cHFAUSUrJvFrzzVWg1HBQt/DwWcjPL1TYhhBCitORpuOosxzCy5F3uqjxd9d/q4vIsOasduKNhAP4ezuW611/xN3jjlyPc0aAW9wcWPX8pOYvnVx0AYETnCO5uEQZAbV83zl7L4L8bWYT75++Fp1LBPe/rn4zr+Aw4l32PPCGEEKIsJFiqzipouxMAr/xgKT3b8uP8TcO8+frJjuW+l8nTcGaCpdw8HSHeroT7ufPagGjjcUOwdCm50IJ2tRMMXlTudgkhhBBlIcFSdVYrCvKywcNMxFFKXi4ljyxVlGBvfWLKK+nmUwdEBnjw47O3k5qtMcn7VNvXDYCLhYOlwi7shT8XwP1L9Jm/LdFq9E8Tpl+BjKugyQQ3P/32Me61wD0AHMs3iiaEEML+SbBUnd33eYVVZXi6LT2n8oMlw8hSUoaGPN3N4ylZGnzy10O5OatxczZNfFnbLz9YulFMsKTJhv97FNIuw+qR0LCPPhDKuKoPijo+A5G368se+xW+e9xyXX3fgk5j9F8nHIbYqTcDKTd/cPYAFH2ep/o9ILSFvuyN83BwlX5qUFFA0eGgzaPJ5TM4bDsKDXtCeAd92YzrcPIPcHACtSOonW9+rVLr98Lzr6cvm5MOF3Zbbq9vBAQ0yP8csiB+Z6ECBRble9eGwEb6r/Ny4fx2y/V6hUBQ/gifNg/ObbNc1jMI/PPrVRT4N85yWTf/m58ZwNmt+s/MHFdffXZ3g3PbQWdhFNTFy3T/wPhd+v9UmOPkAeHtb76/sEcfNJvj6Ap1O918/99+yE1DlaclIO0IqrOeYAjuHZxu/pwBXPobslPM16tSQ707br6/fBCyksyXBf3PmkHCYci8Zno+tKU+6BdC3DISLNUQ1qxZenvtcb7edZ4nu9ZjYq9GZb6Xn7szjg4q8nQKafm/7+KvZ3Lvx38y6o76jOkehYOZp+3CfN1wdFCRq7XwCxXAyRWGLIavB8HJtfpXQfW73/wl5hmk/6XmEQgeAfrgJ+sGZCbpc1gV3KA45YI+CaYl/eff/MWffB42zzY5rQYaAyT8DC7uN4OlG+f0C9Mt6TEFerySX288fHOf5bK3T4DeM/VfpyfC14Mtl20/CgbM13+dnaL/vCxpNRwGfaL/Oi+7+LJNB8Hg/918/9VAy2UbxsDw/7v5fvmDkGchEI68A0b+dvP9qkcsBxRhbeDpzTfff/+U/vtnTmA0jN118/3P4+CahSdCfevCxEM33/8+CS4fwBG4HeB0gbLuATD5zM33616zHJA6ecBrl26+3zgTTseaLwswvUDQtWUeHPvF9Pxjv5kGX0KISifBUg3h7+5MkxAvQnxcLZZJztJUyDSdg4OKQC8XLqdkk5oLORotz367n+RMDRuPJfJ0t/o4UDRYGtgqjMGta5ectiDydnjwK9jxEbj6gGdgfkAUBBEF/rdftwtMvapfJF5Y/oiQUUhzGPTpzUAqK0n/5J1KBSoHqNXgZlmvUGj7+M1zKge0OoXz584SER6GOrjZzbIunvrRL61G/9Jpbn6NYjrF6ugCwc1N21mw6V6hN79WOxcqWyjLuVfIza8d1FCwTYV51y5wP4fiy/rUMX0fdJvlsr51C5WN1u/3Z45fhOn7wCaWR2r865u+D2ho+SEIw6idQa0G4GDhnz3vUNP3/vVBq0FBITU1DW9vL1SGb0jhkR2/SMhKNl+vU6G/c751i//cCvIJL1pWHnIQ4paTYKmGqFvLnbUTuxVbxpBnqaxbnRQU5O3K5ZRsUjQq5q49yeGLqfi5O/HRsDY4qc1nrLB03KzG/fSv4jgUU59KpZ8eMfCpA62GWXfvgIZwz0KTQzqNhkNr1hDevz9qpwKfX2BjGL7aunprRcGYP60r6x1mfVl3fxhTzDRcQc7uJZfV5A8XqlTw7A7r6gXT0aCSPPGH9WUf/dH6sg9/a33ZB74EIE+jIW7NGvr374+Tk4W/G4aROWsYkq1ao+8c68sKISqNzeRZmj17Nl26dMHd3R1fX1+rrlEUhWnTphEaGoqbmxu9evXi1KlTJmWSkpIYPnw43t7e+Pr68uSTT5Kenl4JPaj+KirPEsC0u6NZ+VR70jSwfI9+imTBQ60I8y1mQbYQQghRDdlMsJSbm8sDDzzAmDFjrL7m7bff5oMPPmDRokXs3r0bDw8PYmJiyM6+uRh0+PDhHDlyhNjYWH777Te2bt3K008/XRldqPZS8keWfCogWGob4Y+fuzM/n9P/iI29M4o7GweVeN20nw8z+JPtHLlkYQpGCCGEuMVsJliaMWMGzz//PM2bNy+5MPpRpYULF/L6668zcOBAWrRowVdffcWlS5f46aefADh27Bhr167lf//7Hx07dqRr1658+OGHrFy5kkuXLhV/Axs0+JPtdJi9gdNXzI+cpRmn4co/O5uTp2X8qn/I0anoEOnH81YuGD98MYW/45M5f10ydQshhKge7HbN0tmzZ0lISKBXr17GYz4+PnTs2JGdO3cydOhQdu7cia+vL+3atTOW6dWrFw4ODuzevZvBg80/bZSTk0NOzs2Fqqmp+m1JNBoNGo2Fx53zzxf881a7mprNlbQcktKy0Pi5FDlvGFnycFKVu40qReGhtmF8uOEE7wyORtFp0ei0JV4Xmr8APf56epV9TmVR1d/bW6km9RVqVn+lr/arJvW3NH219vOw22ApISEBgODgYJPjwcHBxnMJCQkEBZlODTk6OuLv728sY87cuXOZMWNGkePr16/H3b3kJ1ViY4t5bLgSKblqQMWmP3dy2Vcpcj7YyQEPDxV/7drGmQrI1VgLeK01HNi1lQNWXpN93QFwYMeB44SmHC1/I26xqvreVoWa1FeoWf2VvtqvmtRfa/qamWndLEaVBkuvvPIK8+bNK7bMsWPHaNKkyS1qkXWmTJnCpEmTjO9TU1MJDw+nT58+eHtb3sdNo9EQGxtL7969LT9VU4m+vrSHi+eTiW7emv7NQ4qc79+/Yu9Xlv7e2B3PxkvHcfYNpn//1hXboEpU1d/bW6km9RVqVn+lr/arJvW3NH01zAyVpEqDpRdeeIGRI0cWW6Z+/frFnrckJEQfDCQmJhIaejN/SmJiIq1atTKWuXLlisl1eXl5JCUlGa83x8XFBReXotNYTk5OVv0QWluuovm46YeLsvKUW3r/0vS3boB+H7xLKTk2+Re6qr63VaEm9RVqVn+lr/arJvXXmr5a+1lUabAUGBhIYGD59z0zp169eoSEhLBx40ZjcJSamsru3buNT9R17tyZ5ORk9u/fT9u2+u0TNm3ahE6no2PH8m8oW914WZHFu6rV9tVPY15KKWF/OCGEEOIWsZmn4eLj4zlw4ADx8fFotVoOHDjAgQMHTHIiNWnShB9/1CeoU6lUTJw4kTfffJNffvmFQ4cOMWLECMLCwhg0aBAA0dHR9O3bl1GjRrFnzx62b9/OuHHjGDp0KGFhYVXRzUpl3PLEzP5w+88n0Xz6Oh78rPB+Y7dWmK8rjg4qvFwdydaUvCBcCCGEqGw2s8B72rRpLFu2zPi+dWv9epbNmzfTo0cPAE6cOEFKys38PJMnTyYjI4Onn36a5ORkunbtytq1a3F1vbn9wPLlyxk3bhw9e/bEwcGBIUOG8MEHH9yaTt1idfzcaRLiha+ZPEop+VudZOVWbYDi5erEiTf7lbzliRBCCHGL2EywtHTpUpYuXVpsGUUxfcJLpVIxc+ZMZs6cafEaf39/vv22FFsg2LBnukfxTPcos+dSs/SjTRWRkLK8JFASQghRndjMNJyoXIYcS95uNhM/CyGEELeEBEsCqNhNdMvr//ZdYPAn2/k07kxVN0UIIYSQYKkm2XM2iZ7vxvH4l3uKnEvNNowsVX2wdCMjl7/jkzmeYF3+CyGEEKIyyZxLDaJTFM5czaBo7u4C03AVsC9cedX2cwPg4g1JHyCEEKLqychSDVJcnqXavu60rONDuH/J27VUttq++mDpUrIES0IIIape1Q8jiFvGy0U/xZZuJlia0KshE3o1vNVNMssQLCWkZqPR6nBSS0wvhBCi6shvoRrEMLKUpdGi0eqquDWWBXi64Kx2QKdAQkp2VTdHCCFEDSfBUg3iWWA9krnRperCwUFFmK8+cahMxQkhhKhqEizVIE5qB1yd9N/y9EJbnnSdt4nb39rEhaTMqmhaERG1PAj3dyM7r/qOgAkhhKgZZM1SDdMwyIvcPB15upvPxOl0CpeSs9Ap4OJUPeLnpY+3R6WSTN5CCCGqngRLNcyvz3Utciw9Nw9D7FQdklICEigJIYSoNiRYEsbs3c6ODrg6qau4NRVPo9Vx/HIai7acIU+n47NH21V1k4QQQtgQCZZEtdpE1+BkYhovf38QJ7UD/ze6c7nq+uv8DR76fBcAjg4q0nPy8HSRH30hhBDWqR4LVMQtM2/tcXq+G8f3+/8zHjNudVINsncbOKsd+Ds+mYP/JaMo5nKOW+94Qprx6zydwo7T18rbPCGEEDWIBEs1zLW0HM5czSAx7Wb+IuNWJ9VoZCk0P3VAtkZHUkZuueoqvMfc1lNXy1WfEEKImkWCpRrG08yWJ25OalrW8aFRkFdVNasIF0c1QV4uAFwsZ66lY5f1I0v3ta4NwJaTV8s9WiWEEKLmqD7zLuKW8HItuuVJt0aBdGsUWFVNsqi2nxtX0nK4lJxFizq+ZapDp1M4kT8NN/L2SH49eIkLSVmcu55JvQCPCmytEEIIeyUjSzWMl4thZElTxS0pWVj+HnH/3Sj7yFJ8UiZZGi0ujg40DfWmfaQ/AFtOXKmQNgohhLB/MrJUwxj2hyucwbs6qpMfLF1KLvv+cIb1So2CvXBUO3Bn4yAycrX4eThXSBuFEELYPwmWahjDmqXUAtNwU386zKbjV5jYqyEPtAuvqqYVUbeWO3X83PBwKXvup0AvV+5vW4e6/u4APHVHPUZ1q19RTRRCCFEDSLBUw/i7OxPm40qtAiMrl1OyuZicZbIFSnUwvGMEwztGlKuOthF+tI3wM76XzOBCCCFKS4KlGqZLgwB2TOlpcsyQwbu6bHVyK6Rla7ickk2j4OrzBKAQQojqSRZ4i5tJKd3sK3bO1mg5kZCGRqszOf7nqWu0nhnLc9/+XUUtE0IIYUskWBLVemTp0cW76ThnA6evpJf62qOXU4lZuJU758eZHL8tzBudonAiMY2ElLIvHhdCCFEzSLBUw2RrtAz6eDu9FmwhK1cL3MzgXZ32hjO4mpZDYmoO/93ILPW1x/OTUUYFepoc9/NwNuZt2npSsnkLIYQongRLNYyz2oF//kvm9JV00nI05Gl1ZOQHTdVpuxMDQ66lsmTxPnZZnzagSWjRdUnd85NwbpFgSQghRAkkWKphHBxUeLrc3PIkO09Hyzo+1AvwMOZgqk5qG3MtlT5YMuRYig7xLnLOkLH8z9PXyCu0pkkIIYQoqPr9dhSVzsvFkbTsPNKz84gKdOTncV2rukkW1fbLH1kqZRZvRVGM03DmRpZa1vHBx82JlCwN//yXYpJeQAghhChIRpZqIMP+cAU3062uyjoNdzE5i7ScPJzUKuoHeBY576h2oGuDAECm4oQQQhRPRpZqoJtbnlT//eFql3HLk4KLu50dzf+f4OEOdekUVYs7G1e/TYSFEEJUHzYzsjR79my6dOmCu7s7vr6+JZbXaDS8/PLLNG/eHA8PD8LCwhgxYgSXLl0yKRcZGYlKpTJ5vfXWW5XUi+rBsOVJWnYesUcTuf2tTUz+7p8qbpV54X5u1PFzIzLAHUWxPsN4/UAPXuzTiIc71LVYpmvDAB7tFEEdP/eKaKoQQgg7ZTMjS7m5uTzwwAN07tyZxYsXl1g+MzOTv/76i6lTp9KyZUtu3LjBhAkTuPfee9m3b59J2ZkzZzJq1Cjjey8v+87qHOzlSpiPK2oHFdfSc7iYnEVSRm5VN8usIG9X/nz5rlJfVz/Qk3F3NayEFgkhhKhpbCZYmjFjBgBLly61qryPjw+xsbEmxz766CM6dOhAfHw8deveHHHw8vIiJCSkwtpa3c27v4Xx68+2nAGqZ9qAW+FqWg5rjySg1eoYeXu9qm6OEEKIashmgqWKkJKSgkqlKjKN99ZbbzFr1izq1q3LsGHDeP7553F0tPzR5OTkkJOTY3yfmqp/RF2j0aDRWF4HZDhXXJlbLTlD3w9PZ3WFt6uq+puj0bL11HUah3gS7udW7Oa5Ry7eYOpPhwn0dGZY+9pl3mi3On5vK0tN6ivUrP5KX+1XTepvafpq7eehUkqzEKQaWLp0KRMnTiQ5OblU12VnZ3P77bfTpEkTli9fbjy+YMEC2rRpg7+/Pzt27GDKlCk8/vjjLFiwwGJd06dPN450FfTtt9/i7m5b619W/+vAn4kOxNTR0T+8euYbWvefiu0JDtwRqqN37ZJ/XC+kw/xDjng4Ksxup6W4+Eejg1f3qsnVqZjcIo/aHhXYcCGEENVaZmYmw4YNIyUlBW/vojn5DKp0ZOmVV15h3rx5xZY5duwYTZo0Kdd9NBoNDz74IIqi8Omnn5qcmzRpkvHrFi1a4OzszOjRo5k7dy4uLi5m65syZYrJdampqYSHh9OnT59iP2yNRkNsbCy9e/fGyanqpr02HLvCZ9vO0ibcF9+gHEhMoG3zaPp3iajQ+1RUf09tPM2aC//iERRB//5NSyy/ev9FOHSEFnVrMWBAuxLL/3bjL+JOXkMJiab/HWWbiqsu39tboSb1FWpWf6Wv9qsm9bc0fTXMDJWkSoOlF154gZEjRxZbpn79+uW6hyFQOn/+PJs2bSo2mAHo2LEjeXl5nDt3jsaNG5st4+LiYjaQcnJysuqH0NpylSVDo3DgQgrebs445I+6+Hm4VFqbytvf8Fr64Z7LqTlW1XPqagYATcN8rCrfo3EQcSev8efpJMbe1ajM7YSq/97eSjWpr1Cz+it9tV81qb/W9NXaz6JKg6XAwEACAysvx40hUDp16hSbN2+mVq1aJV5z4MABHBwcCAoKqrR2VTUvY+oADQ2DPKkX4EGAl/lRtOqgtq9+atPaLU+MmbtDrHuqsXvjIPj1KPvOJ5GRk4eHS41ayieEEKIENvNbIT4+nqSkJOLj49FqtRw4cACABg0a4Ompz9DcpEkT5s6dy+DBg9FoNNx///389ddf/Pbbb2i1WhISEgDw9/fH2dmZnTt3snv3bu688068vLzYuXMnzz//PI888gh+fva7/YVXfjCQnp3H2/e3rOLWlKzglieKohS7CFtRlJt7woUWP4poEFnLnbr+7sQnZbLzzHV6NQ0uf6OFEELYDZsJlqZNm8ayZcuM71u3bg3A5s2b6dGjBwAnTpwgJSUFgIsXL/LLL78A0KpVK5O6DNe4uLiwcuVKpk+fTk5ODvXq1eP55583WY9kj2xpuxOAUB9XALI0Wm5kavD3cLZY9kpaDjcyNTiooEFQ0W1OzFGpVHRrFMCKPRc4ey2jQtoshBDCfthMsLR06dIScywVfLAvMjKyxIzPbdq0YdeuXRXRPJviadzuxDaCJVcnNQGeLlxLz+FSclaxwdKxy/pRpfqBnrg6qa2+x/i7GjK5bxO8XWvGXL4QQgjr2UywJCqOV4Fgqcvcjfi6O/PdmM64O1ffH4e2Eb4kZ2ooKdFFs9o+fPhwa0qbDyPI27XMbRNCCGHfqu9vR1FpPF0c8XBWk5On41JKNpdTs3F1tH4Upip89mjJKQAAAjxduKdlWLnupdUpqB3KlpxSCCGE/bGZjXRFxXF1UnNkZl/WTuwG6Bd8O0hwwN5zSQz6eDujv95f1U0RQghRjcjIUg2Wmq1P8+7jbjvrdHQ6xWJgl5unY+mOszQJ8aZrg4BSB4Aezo4cuJCMm5OanDwtLtV8tE0IIcStISNLNVhKlj5YsoVFzXvOJtFxzgYGf7rDYpnTV9KZs+Y44779q9gtTiyJDvUi0MuFLI2WfedulKO1Qggh7IkESzXU9F+O8PiXewHbCJY8XRxJTM3hv6RMi2UM+ZWahHqXaUNclUpFt4b6JKlbT14tW0OFEELYHQmWaqgTCWnGr73dqv9sbG1ffWLK6xm5ZOVqzZY5nt+naCszd5vTvbE+WNoiwZIQQoh8EizVUIZcS3BzO5HqzNvNEc/8zOMXLWx7Ysix1MTKzN3m3NEgAJVKH3glpmaXuR4hhBD2Q4KlGsqQa2lKvyZMu6dpFbemZCqVijBffS4kS3vEGUaWrN0Tzhw/D2da1PEFZHRJCCGEXvWffxGVwrA/nK1seQL6qbiTielmR5aupedwNS0HlQoaBZc9WAIY0DyEOr5u1Mnfk04IIUTNJsFSDWXYH85WtjwB0w11CzOswYrwd8fDpXw/1k93iyrX9UIIIeyLBEs1lGHN0tId5+gZHcQd+U+BVWdNQ33oWM+fUN+iW5O0jfDj13FdjbmjhBBCiIoiwVINVTBdgEarq8KWWG9Yx7oM61jX7DlXJzXN6/hU6P0uJmfx2o+HeK1/NA3LObUnhBDCdskC7xpqWMe6RNbSPwVnC3mWqsKcNceIO3GViasOkJtnGwGlEEKIiifBUg1mzODtZlvBUm6eDkVRjO/ztDpe+/EQX+08V6FBzRt3N8XP3Ykjl1JZuOFkhdUrhBDCtkiwVEMpikJq/pNwPjYSLCmKQtd5m2g89Q8SCuRAOnstg+W745n3x3EcK3BD4CBvV+be1xyAT7ecYc/ZpAqrWwghhO2QYKmGOnM1Ha1OPzpjK9NwKpUKlQoUxfSJuGP5T8I1DvEq9ea5JenbLJQH2tZBUeD5VQdkAbkQQtRAEizVUGqHm996Vyfb+TEI88lPH1Ag19LxCsjcXZw37r2Nuv7uXEzOYvovRyrlHkIIIaov2/ktKSpUvQAP3hzUjEWPtCnTprNVxZBr6b8CI0sVsSdccTxdHHnvoZY4qODwxRTSZHRJCCFqFEkdUIM90imiqptQanXyN9S9dAtHlgDaRviz+LH2dI6qhauTutLuI4QQovqRYEnYlDBf02m4lEwNl1L0i70bV9LIksGdTYIqtX4hhBDVk0zDCZtSeMuT01f1U3C1fd1u2UJ1rU7h482nWbbj3C25nxBCiKolI0vCpkT4e9Chnj8NgzwB/fTYP2/0IbFAKoHKtvZwAu+sO4GzowOd6teq9BEtIYQQVUtGloRNqVvLnf8b3ZnZg5sbj/m4OdHoFm5H0r95CHc2DiQ3T8fEVQfIydPesnsLIYS49SRYEqKUVCoV8+5vgb+HM8cup7JgvWT3FkIIeybBkrBJuXk6MnPzeGzJHmb+epT0nLxbev8gL1feys/u/fm2f9kt2b2FEMJuSbAkbM4r3x+k8dQ/mPfHcbacvMry3edxq4LH+fvcFsLQ9uEoCrz0/WEyb228JoQQ4haRYEnYHE8XRxQFNh6/AuhTBqgreJsTa029uykRtdy5npHL+TTbSe4phBDCevI0nLA5hlxLhizeTarwaTQPF0c+ergNDmg5vX8bAOk5eaw5dJkBzUPxcJG/YkIIYetkZEnYHEOuJYMmIZWXudsazev4mDyN9/vBS0z+7iDtZ29g8nf/sP98EoqiVGELhRBClIfNBEuzZ8+mS5cuuLu74+vra9U1I0eOzN+p/uarb9++JmWSkpIYPnw43t7e+Pr68uSTT5Kenl4JPRAVpbZvoWAptHrlOXJ1UlMvwIPMXC3/t+8/hny6k54LtrBoyxmupN26fFBCCCEqhs0ES7m5uTzwwAOMGTOmVNf17duXy5cvG18rVqwwOT98+HCOHDlCbGwsv/32G1u3buXpp5+uyKaLClY4WIqu4pGlwga2qs2mF7qz+pnO3N+2Dm5Oav69msFbfxyn61ubuZGRW9VNFEIIUQo2s6BixowZACxdurRU17m4uBASEmL23LFjx1i7di179+6lXbt2AHz44Yf079+f+fPnExYWVq42i8rh6266rYmfh3MVtcQylUpF+0h/2kf6M/3e2/jtn0v8374LeLo6mbT307gzNA3zpktULZzUNvN/FyGEqFFsJlgqq7i4OIKCgvDz8+Ouu+7izTffpFatWgDs3LkTX19fY6AE0KtXLxwcHNi9ezeDBw82W2dOTg45OTnG96mp+l3vNRoNGo3GYlsM54orY08qs7+DW4WiU2Bk54hq8XkW11cXBxjSOpQhrUPJ1miNZa6k5fD2uuMoCvi4OdIrOoh+twXTuX4tnB3LFzgpioJKVTlP58nPsf2SvtqvmtTf0vTV2s9DpdjYytOlS5cyceJEkpOTSyy7cuVK3N3dqVevHmfOnOHVV1/F09OTnTt3olarmTNnDsuWLePEiRMm1wUFBTFjxgyLU37Tp083jnQV9O233+Lu7l6mfoma50YOxF504J8kFemam4GNm1qhub9C12AdEcUsx1IUSM+D69kQWaDclycdOJikopG3wp1hCo19FCopbhJCCJuWmZnJsGHDSElJwdvb8pKOKh1ZeuWVV5g3b16xZY4dO0aTJk3KVP/QoUONXzdv3pwWLVoQFRVFXFwcPXv2LFOdAFOmTGHSpEnG96mpqYSHh9OnT59iP2yNRkNsbCy9e/fGycnJYjl7UZP6W9a+Dge0OoW9526w9kgi644mci09lz1XVQy5ozn9W9cGICVLw75zN/j3egZnrmbw79UM/r2WQUpWHioVHJzaE9f8xJw7NEc4cP0ix1NUHE+BRkGePH57BPe0CMWlnCNW5emrrapJ/ZW+2q+a1N/S9NUwM1SSKg2WXnjhBUaOHFlsmfr161fY/erXr09AQACnT5+mZ8+ehISEcOXKFZMyeXl5JCUlWVznBPp1UC4uLkWOOzk5WfVDaG05e1GT+luWvjoBdzQO5o7GwcwcpLD3XBJ/HLpM32a1jXX9sDOeOWuOF7lWpYJwP3eSs3WEu7sCMKlPEx7vWp9Vey+wau8FTl5JZ8qPR3g39jRjekTxZNd65e4n1KzvK9Ss/kpf7VdN6q81fbX2s6jSYCkwMJDAwMBbdr///vuP69evExoaCkDnzp1JTk5m//79tG3bFoBNmzah0+no2LHjLWuXEAZqBxWd6teiU/1aJscP/pfCbWHeRAV66l9BHkQFelIvwMM4omQQ7O1KsLcrb9xzGxN7NWLlnni+3H6OhNRsLidn3cruCCGEXbCZBd7x8fEkJSURHx+PVqvlwIEDADRo0ABPT08AmjRpwty5cxk8eDDp6enMmDGDIUOGEBISwpkzZ5g8eTINGjQgJiYGgOjoaPr27cuoUaNYtGgRGo2GcePGMXToUHkSTlQrHw1rU6brfNycGN09iie61uP3g5dpX8/feG73v9f5YttZRt1Rjw71/CttQbgQQtg6mwmWpk2bxrJly4zvW7duDcDmzZvp0aMHACdOnCAlJQUAtVrNwYMHWbZsGcnJyYSFhdGnTx9mzZplMoW2fPlyxo0bR8+ePXFwcGDIkCF88MEHt65jQtwCTmoHBuWvfzL4YttZNhxLZMOxRJqGehMZ4I6rkxo3JzWeLo5M6R9tLLvt1FWup+fi5qzGyUHhQjrodDb1bIgQQpSZzQRLS5cuLTHHUsEH+9zc3Fi3bl2J9fr7+/Ptt9+Wt3lC2JxX+jUh0MuFH/76j6OXUzl6+eZCx8LB0hfbzrL15NUCVzvyzfmt3NuqNve2DOO2MG8ZmRJC2C2bCZaEEBWrQZAnc+9rzot9GrHl5FUycvLI0mjJytUVSTXQLMwbnU4hS6MlMyePs1dTSUjN4fOt/7JyTzz7Xu+Ns6MES0II+yTBkhA1XC1PF+5rU6fYMpP73kzfodFo+Pm3NbjVb8uaw1cI8HQ2JtFUFIXRX++nXaQfd7cII6zQ1jRCCGGLJFgSQpSakwP0aRrMgJamQdaBC8msP5rI+qOJzFlznA71/Lm3ZRj9m4fiXw23pRFCCGvIZlRCiApTP8CTWYOa0SFS/9TdnrNJvP7TYdq+GcuAD7axxWTdkxBC2AYZWRJCVBgfdyce7RTBo50iuJicxW//XOKXfy5x5FIqRy6l4lxgs+Dd/15n04krdK5fi/aR/ni4yD9HQojqSf51EkJUitq+bozuHsXo7lEkpmaz69/rtK7razz/x+EElu44x2db/sXRQUWLOj50jqpF5/oBtI3ww81ZbblyIYS4hSRYEkJUumBvVwa2Ms3z1K1RABk5eez89zr/3cjir/hk/opP5uP/b+/Oo6K4s76Bf6vpBVmaXRZZREVwAdwNGsSIATUymsz7moXHg2OiY8So4zJqJgZFE9EkJtFDknk1R308JhrzBDV51IwTBSODCiiCBggi7o0oCjQg0HTf9w+kQgPdCra0wv2c08euqh+/vrduc/paVXQdK4SFRMCpd8PhbNPwnWhl1XWwtZTBQsJ/cccY63jcLDHGzGJcgCvGBbgCAK7drUbapVKcLCxF2qVS6IjERgkAFn13DqeL7iKwhx0Gedsj2NMeg73t4aq0NFf4jLEuhJslxpjZeTlawcvRCtOGeYGIUHG/Xm97QYkalQ+OQqVdKhXXuyktMaq3Eza+Okhctz21CLX1OsgsJJBJJZBbCA3PLSRwsJLjeT9nk8ZeW69FXb0OtpYNN+Ssqq3HP5Jy4Otsg57OVuj14N/G7YyxZw83S4yxp4ogCLCz0m8skpe8gIISNbKuliHrWsPj91tqFFfU4HqzmwMnJhfitrq21bn7uytxcEGouPzWjgzUaXXo7WIt3qS4T3cbONvIW/1G8hqNFvnFauTcKMf5G+U4f7Mc+cVqxL7QBwvH9wUAXC6twr6smy1+1tlGAV/nhobw/w7zAgBodYS6et0TuT6LiKCurYdOR1BayiDhU5iMtRs3S4yxp56FRECAmxIBbkq8NsIbQMMRnPM3ytH8FnWTg9xRfl8DjZagqdehXqdD3YPnPk5W4jidjvCfwjuortM2u5ULoLSUYkxfF/EGxhV1QFRiGi6WVKK+lXviXSypFJ87WSuwbEIAiu5U4vKdaly6U4U7lbXiY3w/V3FsQYkaEz77FQqpBHbdZOLD3koGZTcZooI88EJA94YYajQ4fekuFDIJyqo1KLuvQXl1He5Va1BWrcHkYHe84N8wNv3yXbz2/05C+yBWidBwU2UHKzkcrOV4dbgXpj1o2CpqNDiUo4K9lRxKhQTXq4DfVBWQSWUQhIYmz8W24ZRobb0W1+7ehyAAAgCJIOh927vSUgaHB9+npdHqUFxeY7CmNgqpOFarI9y4d7/FGAKBCLBWSMUYdDrCxduVIPpjOxGge3C7K7tuMng5/lHnvOKG2/gIEMS4BQGor9eirFlPfbW0GgSCgIakmuamkEnQ3faP0743y+6Lr9mc3EKC7k1OEavK74u1aE5mIdE7nXyrogYara7VsRYSAe52f3zRa0lFDeoMjJUIgt6Xwt5W1+JuLXCj7D6kUo3eWEEQ0KPJ2DuVtajRaFudFwA8Hf7Yv6WVtbhvZKyHXTexUb9bVYfqunqDY93tuonXJd6rqkNVk7FuSktILcz3bUfcLDHGnknWCilG9nJqsT4uasAjz7Fj5ggUllSi8HYlCm9X4WJJJa7dq0ZFTb3eh4WNDLhSWoV6HcHRWo6BPewQ2EOJgR52GNjDDp4Of3zQuNlZ4u2xvfVeR12jedA4VWKAh1Jcf6W0GgBQW69DiboWJc2OiPVzU4rN0qXbVXjrvzMM5tLLxVpslmwUUr0PZx0B96o1uFetAe5U6TVsV0ursex/cprMJMVH2SfFpfnhflj0Yl8x3ohPjxuMYfaYXnj3wT0Fi8trELrhmMGx//WcN9ZODQTQcAH/mI8Mj/3zEE98Mi0YAHBfozUaw6RAN3wRPRRAw9G1CZ/9anBsf3sJ3miyHPFZCmo0rTcfI30dseevIeJy1OYTKK2qa3VskKcdDsx7Xlz+P1+m4UZZy2YQaLjt0L8XhYnL/7X1FAqaNN9N9bDvhtTl48TlWf+dgXPXy1sd62gtx5mVL4rLC7/LxunLUqw+03J/WMokyFszUVxeuvccjuUb/k60ywkvic/f338B/5ujMjj2t/hIWMkbWo0P/jcX/3PmusGxGe+NF69V3Hjkd+w8eUXcdnJFONzszHeNIjdLjLEuSSIRMLynI4Y/+ALNRjUaLS6XVqHpQQOJAGyZPgS9uivhbmfZ5psG21rKEOhph0BPO731Ef1dkb0qAuXVGpTfb/kY2euP2CwEAcGedqit14lHnxys5LCzksG+m1xvbG8XG5x6Nxx23WSQCALK7tehrFqDu1V1KKuuQ5/utuJYuVSCcQHdcbeqDneralGurobC0hKEhmbDuskpQokgQGkpBQFAk6M5jWQWf+wXQQCsHvxs47CmR21kzY4SWBk4FSkRBChkEr1lR2u5eIQIECAR8OCokQB7K/1vine2kT84CtWQDz2Ih4ggt9BvdmwUUlgI2gexQi/2xlv6NFJIJbCUtX6kQ94sN4Xs0cfKpRIopK2Pbb6+LWNlFhLIBILEouV+VkgtWow1NG9zUgvhkcfK2jC2LfN2BIHIwHFE9sgqKipgZ2eH8vJyKJVKg+M0Gg0OHjyISZMmQSbr/Bd7dqV8OdfOqyvly7l2Xl0p37bk+qif309P28YYY4wx9hTiZokxxhhjzAhulhhjjDHGjOBmiTHGGGPMCG6WGGOMMcaM4GaJMcYYY8wIbpYYY4wxxozgZokxxhhjzAhulhhjjDHGjOBmiTHGGGPMCG6WGGOMMcaM4GaJMcYYY8wIbpYYY4wxxozgZokxxhhjzAipuQPoDIgIAFBRUWF0nEajQXV1NSoqKiCTyToiNLPqSvlyrp1XV8qXc+28ulK+bcm18XO78XPcEG6WTECtVgMAvLy8zBwJY4wxxtpKrVbDzs7O4HaBHtZOsYfS6XS4efMmbG1tIQiCwXEVFRXw8vLCtWvXoFQqOzBC8+hK+XKunVdXypdz7by6Ur5tyZWIoFar4eHhAYnE8JVJfGTJBCQSCTw9PR95vFKp7PRv1qa6Ur6ca+fVlfLlXDuvrpTvo+Zq7IhSI77AmzHGGGPMCG6WGGOMMcaM4GapAykUCsTFxUGhUJg7lA7RlfLlXDuvrpQv59p5daV8n0SufIE3Y4wxxpgRfGSJMcYYY8wIbpYYY4wxxozgZokxxhhjzAhulhhjjDHGjOBmqQMlJiaiZ8+esLS0xMiRI3H69Glzh2Ryq1atgiAIeo+AgABzh2Uyx48fR1RUFDw8PCAIAvbt26e3nYjw/vvvw93dHd26dcP48eNRUFBgnmAf08NynTFjRotaT5gwwTzBPqZ169Zh+PDhsLW1Rffu3TF16lTk5+frjampqUFsbCycnJxgY2ODP//5z7h165aZIm6/R8l17NixLWo7Z84cM0X8eL788ksEBQWJX1AYEhKCQ4cOids7S12Bh+fameraXEJCAgRBwMKFC8V1pqwtN0sdZM+ePVi0aBHi4uJw5swZBAcHIzIyEiUlJeYOzeQGDBgAlUolPk6cOGHukEymqqoKwcHBSExMbHX7hg0bsGnTJnz11Vc4deoUrK2tERkZiZqamg6O9PE9LFcAmDBhgl6tv/322w6M0HRSUlIQGxuLkydP4siRI9BoNIiIiEBVVZU45m9/+xt+/PFH7N27FykpKbh58yZeeeUVM0bdPo+SKwDMmjVLr7YbNmwwU8SPx9PTEwkJCcjMzERGRgbGjRuHKVOm4MKFCwA6T12Bh+cKdJ66NpWeno5//vOfCAoK0ltv0toS6xAjRoyg2NhYcVmr1ZKHhwetW7fOjFGZXlxcHAUHB5s7jA4BgJKSksRlnU5Hbm5u9NFHH4nrysrKSKFQ0LfffmuGCE2nea5ERDExMTRlyhSzxPOklZSUEABKSUkhooY6ymQy2rt3rzgmNzeXAFBaWpq5wjSJ5rkSEYWFhdGCBQvMF9QT5uDgQFu3bu3UdW3UmCtR56yrWq0mPz8/OnLkiF5+pq4tH1nqAHV1dcjMzMT48ePFdRKJBOPHj0daWpoZI3syCgoK4OHhgV69eiE6OhpXr141d0gdoqioCMXFxXp1trOzw8iRIztlnQEgOTkZ3bt3h7+/P95++22UlpaaOySTKC8vBwA4OjoCADIzM6HRaPRqGxAQAG9v72e+ts1zbbRr1y44Oztj4MCBWLFiBaqrq80RnklptVrs3r0bVVVVCAkJ6dR1bZ5ro85W19jYWLz00kt6NQRM/zvLN9LtAHfu3IFWq4Wrq6veeldXV+Tl5Zkpqidj5MiR2L59O/z9/aFSqbB69WqEhobi/PnzsLW1NXd4T1RxcTEAtFrnxm2dyYQJE/DKK6/A19cXhYWFePfddzFx4kSkpaXBwsLC3OG1m06nw8KFCzF69GgMHDgQQENt5XI57O3t9cY+67VtLVcAeOONN+Dj4wMPDw9kZ2dj2bJlyM/Pxw8//GDGaNsvJycHISEhqKmpgY2NDZKSktC/f39kZWV1uroayhXofHXdvXs3zpw5g/T09BbbTP07y80SM6mJEyeKz4OCgjBy5Ej4+Pjgu+++w5tvvmnGyJipvfbaa+LzwMBABAUFoXfv3khOTkZ4eLgZI3s8sbGxOH/+fKe61s4QQ7nOnj1bfB4YGAh3d3eEh4ejsLAQvXv37ugwH5u/vz+ysrJQXl6O77//HjExMUhJSTF3WE+EoVz79+/fqep67do1LFiwAEeOHIGlpeUTfz0+DdcBnJ2dYWFh0eIq/Fu3bsHNzc1MUXUMe3t79O3bFxcvXjR3KE9cYy27Yp0BoFevXnB2dn6maz1v3jz89NNPOHbsGDw9PcX1bm5uqKurQ1lZmd74Z7m2hnJtzciRIwHgma2tXC5Hnz59MHToUKxbtw7BwcH4/PPPO2VdDeXamme5rpmZmSgpKcGQIUMglUohlUqRkpKCTZs2QSqVwtXV1aS15WapA8jlcgwdOhS//PKLuE6n0+GXX37RO5fcGVVWVqKwsBDu7u7mDuWJ8/X1hZubm16dKyoqcOrUqU5fZwC4fv06SktLn8laExHmzZuHpKQkHD16FL6+vnrbhw4dCplMplfb/Px8XL169Zmr7cNybU1WVhYAPJO1bY1Op0NtbW2nqqshjbm25lmua3h4OHJycpCVlSU+hg0bhujoaPG5SWtrmuvR2cPs3r2bFAoFbd++nX777TeaPXs22dvbU3FxsblDM6nFixdTcnIyFRUVUWpqKo0fP56cnZ2ppKTE3KGZhFqtprNnz9LZs2cJAG3cuJHOnj1LV65cISKihIQEsre3p/3791N2djZNmTKFfH196f79+2aOvO2M5apWq2nJkiWUlpZGRUVF9O9//5uGDBlCfn5+VFNTY+7Q2+ztt98mOzs7Sk5OJpVKJT6qq6vFMXPmzCFvb286evQoZWRkUEhICIWEhJgx6vZ5WK4XL16k+Ph4ysjIoKKiItq/fz/16tWLxowZY+bI22f58uWUkpJCRUVFlJ2dTcuXLydBEOhf//oXEXWeuhIZz7Wz1bU1zf/az5S15WapA23evJm8vb1JLpfTiBEj6OTJk+YOyeReffVVcnd3J7lcTj169KBXX32VLl68aO6wTObYsWMEoMUjJiaGiBq+PmDlypXk6upKCoWCwsPDKT8/37xBt5OxXKurqykiIoJcXFxIJpORj48PzZo165lt/lvLEwBt27ZNHHP//n2aO3cuOTg4kJWVFb388sukUqnMF3Q7PSzXq1ev0pgxY8jR0ZEUCgX16dOHli5dSuXl5eYNvJ1mzpxJPj4+JJfLycXFhcLDw8VGiajz1JXIeK6dra6tad4smbK2AhFRO46AMcYYY4x1CXzNEmOMMcaYEdwsMcYYY4wZwc0SY4wxxpgR3CwxxhhjjBnBzRJjjDHGmBHcLDHGGGOMGcHNEmOMMcaYEdwsMdbFXL58GYIgiLc6eBrk5eXhueeeg6WlJQYNGtTqGCLC7Nmz4ejoaPb4n8Z92F7JyckQBKHFPbSehFWrVhmsL2NPM26WGOtgM2bMgCAISEhI0Fu/b98+CIJgpqjMKy4uDtbW1sjPz9e7l1NThw8fxvbt2/HTTz9BpVJh4MCBHRLbjBkzMHXqVL11Xl5eHRrDs0gQBOzbt09v3ZIlSwzWl7GnGTdLjJmBpaUl1q9fj3v37pk7FJOpq6tr988WFhbi+eefh4+PD5ycnAyOcXd3x6hRo+Dm5gapVNru13tcFhYWZo/hWWRjY2Owvow9zbhZYswMxo8fDzc3N6xbt87gmNZOWXz22Wfo2bOnuNx41OPDDz+Eq6sr7O3tER8fj/r6eixduhSOjo7w9PTEtm3bWsyfl5eHUaNGwdLSEgMHDkRKSore9vPnz2PixImwsbGBq6srpk+fjjt37ojbx44di3nz5mHhwoVwdnZGZGRkq3nodDrEx8fD09MTCoUCgwYNwuHDh8XtgiAgMzMT8fHxEAQBq1atajHHjBkz8M477+Dq1asQBEHcBz179sRnn32mN3bQoEF6cwiCgK1bt+Lll1+GlZUV/Pz8cODAAb2fuXDhAiZPngylUglbW1uEhoaisLAQq1atwo4dO7B//34IggBBEJCcnNzqabiUlBSMGDECCoUC7u7uWL58Oerr6/X21/z58/H3v/8djo6OcHNzazXX5rZu3Yp+/frB0tISAQEB+OKLL8Rto0aNwrJly/TG3759GzKZDMePHwcA7Ny5E8OGDYOtrS3c3NzwxhtvoKSkxODrPcr7Lj09HS+++CKcnZ1hZ2eHsLAwnDlzRtzeOPbll1/Wq1fzuR/23mjczz/88ANeeOEFWFlZITg4GGlpaeKYK1euICoqCg4ODrC2tsaAAQNw8OBBo/uUsbbiZokxM7CwsMCHH36IzZs34/r1648119GjR3Hz5k0cP34cGzduRFxcHCZPngwHBwecOnUKc+bMwV//+tcWr7N06VIsXrwYZ8+eRUhICKKiolBaWgoAKCsrw7hx4zB48GBkZGTg8OHDuHXrFqZNm6Y3x44dOyCXy5Gamoqvvvqq1fg+//xzfPLJJ/j444+RnZ2NyMhI/OlPf0JBQQEAQKVSYcCAAVi8eDFUKhWWLFnS6hyNH6oqlQrp6elt2kerV6/GtGnTkJ2djUmTJiE6Ohp3794FANy4cQNjxoyBQqHA0aNHkZmZiZkzZ6K+vh5LlizBtGnTMGHCBKhUKqhUKowaNarF/Ddu3MCkSZMwfPhwnDt3Dl9++SW+/vprrF27tsX+sra2xqlTp7BhwwbEx8fjyJEjBuPetWsX3n//fXzwwQfIzc3Fhx9+iJUrV2LHjh0AgOjoaOzevRtNb/G5Z88eeHh4IDQ0FACg0WiwZs0anDt3Dvv27cPly5cxY8aMNu2/5tRqNWJiYnDixAmcPHkSfn5+mDRpEtRqNQCI9dm2bZvRej3svdHoH//4B5YsWYKsrCz07dsXr7/+utiIxsbGora2FsePH0dOTg7Wr18PGxubx8qPsRZMcKNfxlgbxMTE0JQpU4iI6LnnnqOZM2cSEVFSUhI1/ZWMi4uj4OBgvZ/99NNPycfHR28uHx8f0mq14jp/f38KDQ0Vl+vr68na2pq+/fZbIiIqKioiAJSQkCCO0Wg05OnpSevXryciojVr1lBERITea1+7do0AUH5+PhE13OF78ODBD83Xw8ODPvjgA711w4cPp7lz54rLwcHBFBcXZ3Se5rkTEfn4+NCnn36qt675XADovffeE5crKysJAB06dIiIiFasWEG+vr5UV1fX6us2rVejxn149uxZIiJ69913yd/fn3Q6nTgmMTGRbGxsxNqEhYXR888/rzfP8OHDadmyZQZz7t27N33zzTd669asWUMhISFERFRSUkJSqZSOHz8ubg8JCTE6Z3p6OgEgtVpNRETHjh0jAHTv3j0ierT3XXNarZZsbW3pxx9/FNcBoKSkJL1xzed+2HujcT9v3bpV3H7hwgUCQLm5uUREFBgYSKtWrTIYG2OmwEeWGDOj9evXY8eOHcjNzW33HAMGDIBE8sevsqurKwIDA8VlCwsLODk5tTj1EhISIj6XSqUYNmyYGMe5c+dw7Ngx2NjYiI+AgAAADdcONRo6dKjR2CoqKnDz5k2MHj1ab/3o0aMfK+e2CgoKEp9bW1tDqVSK+yMrKwuhoaGQyWTtnj83NxchISF6F+iPHj0alZWVekf0msYBAO7u7gZPiVVVVaGwsBBvvvmmXh3Wrl0r1sDFxQURERHYtWsXAKCoqAhpaWmIjo4W58nMzERUVBS8vb1ha2uLsLAwAMDVq1fbne+tW7cwa9Ys+Pn5wc7ODkqlEpWVlW2asy3vjab7zd3dHQDE/TZ//nysXbsWo0ePRlxcHLKzs9ubFmMGcbPEmBmNGTMGkZGRWLFiRYttEolE7/QK0HBKpbnmH/KCILS6TqfTPXJclZWViIqKQlZWlt6joKAAY8aMEcdZW1s/8pxPwuPso8b90a1btycXYBviaK6yshIAsGXLFr0anD9/HidPnhTHRUdH4/vvv4dGo8E333yDwMBAsVmuqqpCZGQklEoldu3ahfT0dCQlJQEwfEH+o+zTmJgYZGVl4fPPP8d//vMfZGVlwcnJ6bEu8jem6X5rbEgb99tbb72FS5cuYfr06cjJycGwYcOwefPmJxIH67q4WWLMzBISEvDjjz/qXbQKNBw1KC4u1vvgMuX3+jT9wK2vr0dmZib69esHABgyZAguXLiAnj17ok+fPnqPtjRISqUSHh4eSE1N1VufmpqK/v37P3YOLi4uUKlU4nJFRQWKioraNEdQUBB+/fXXVpssAJDL5dBqtUbn6NevH9LS0vRqlZqaCltbW3h6erYpnkaurq7w8PDApUuXWtTA19dXHDdlyhTU1NTg8OHD+Oabb/SOKuXl5aG0tBQJCQkIDQ1FQECA0Yu7gUd736WmpmL+/PmYNGkSBgwYAIVCoXfxP9DQ4Bjbb6Z8b3h5eWHOnDn44YcfsHjxYmzZsqVNP8/Yw3CzxJiZBQYGIjo6Gps2bdJbP3bsWNy+fRsbNmxAYWEhEhMTcejQIZO9bmJiIpKSkpCXl4fY2Fjcu3cPM2fOBNBw0ezdu3fx+uuvIz09HYWFhfj555/xl7/85aGNQ3NLly7F+vXrsWfPHuTn52P58uXIysrCggULHjuHcePGYefOnfj111+Rk5ODmJgYWFhYtGmOefPmoaKiAq+99hoyMjJQUFCAnTt3Ij8/H0DDX3ZlZ2cjPz8fd+7cabWpmjt3Lq5du4Z33nkHeXl52L9/P+Li4rBo0SK9U6RttXr1aqxbtw6bNm3C77//jpycHGzbtg0bN24Ux1hbW2Pq1KlYuXIlcnNz8frrr4vbvL29IZfLsXnzZly6dAkHDhzAmjVrjL7mo7zv/Pz8sHPnTuTm5uLUqVOIjo5ucYSuZ8+e+OWXX1BcXGzwKzJM8d5YuHAhfv75ZxQVFeHMmTM4duyY2PQzZircLDH2FIiPj29xOqZfv3744osvkJiYiODgYJw+fbrVvxRrr4SEBCQkJCA4OBgnTpzAgQMH4OzsDADi//i1Wi0iIiIQGBiIhQsXwt7evs0f/vPnz8eiRYuwePFiBAYG4vDhwzhw4AD8/PweO4cVK1YgLCwMkydPxksvvYSpU6eid+/ebZrDyckJR48eRWVlJcLCwjB06FBs2bJFPPUza9Ys+Pv7Y9iwYXBxcWlxJAQAevTogYMHD+L06dMIDg7GnDlz8Oabb+K99957rPzeeustbN26Fdu2bUNgYCDCwsKwfft2vSNLQMOpuHPnziE0NBTe3t7iehcXF2zfvh179+5F//79kZCQgI8//tjoaz7K++7rr7/GvXv3MGTIEEyfPh3z589H9+7d9cZ88sknOHLkCLy8vDB48OBWX8sU7w2tVovY2Fj069cPEyZMQN++ffW+XoExUxCo+clpxhhjjDEm4iNLjDHGGGNGcLPEGGOMMWYEN0uMMcYYY0Zws8QYY4wxZgQ3S4wxxhhjRnCzxBhjjDFmBDdLjDHGGGNGcLPEGGOMMWYEN0uMMcYYY0Zws8QYY4wxZgQ3S4wxxhhjRnCzxBhjjDFmxP8HMrQMM1REHDgAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ]